dtk-client 0.6.7 → 0.6.8

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

@@ -1,5 +1,6 @@
 dtk_require_common_commands('thor/clone')
 dtk_require_common_commands('thor/list_diffs')
+dtk_require_common_commands('thor/puppet_forge')
 dtk_require_common_commands('thor/push_to_remote')
 dtk_require_common_commands('thor/pull_from_remote')
 dtk_require_common_commands('thor/push_clone_changes')
@@ -8,6 +9,7 @@ dtk_require_common_commands('thor/edit')
 dtk_require_common_commands('thor/reparse')
 dtk_require_common_commands('thor/purge_clone')
 dtk_require_common_commands('thor/common')
+
 dtk_require_from_base('configurator')
 dtk_require_from_base('command_helpers/service_importer')
 dtk_require_from_base('command_helpers/test_module_creator')
@@ -18,7 +20,41 @@ DEFAULT_COMMIT_MSG = "Initial commit."
 PULL_CATALOGS = ["dtkn"]
 
 module DTK::Client
+  class CommonModule
+    # TODO: For Aldin; looking to use nested file structure if helpers just relate to one file in common;
+    # example here is import which is helper for module.rb
+    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 in #{location}: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
+      OsUtil.print("There are missing module dependencies mentioned in #{location}: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+      OsUtil.print("There are ambiguous module dependencies mentioned in #{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
+    include PuppetForgeMixin
     include CloneMixin
     include PushToRemoteMixin
     include PullFromRemoteMixin
@@ -120,7 +156,7 @@ module DTK::Client
         msg = "Module '#{module_name}' "
         if version then msg << "version #{version} has been deleted"
         else  msg << "has been deleted"; end
-        OsUtil.print(msg,:yellow)
+        OsUtil.print(msg, :yellow)
       end
 
       Response::Ok.new()
@@ -146,15 +182,18 @@ module DTK::Client
       post rest_url("attribute/set"), post_body
     end
 
-    def push_module_aux(context_params, internal_trigger=false)
+    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_location = OsUtil.module_location(module_type, module_name, version)
 
+      git_import = opts[:git_import]
+      opts.merge!(:update_from_includes => true, :force_parse => true) unless git_import
+
       reparse_aux(module_location)
-      push_clone_changes_aux(module_type.to_sym, module_id, version, options["message"]||DEFAULT_COMMIT_MSG, internal_trigger)
+      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)
@@ -180,80 +219,114 @@ module DTK::Client
       end
     end
 
-     def import_git_module_aux(context_params)
-      git_repo_url, module_name = context_params.retrieve_arguments([:option_1!, :option_2!],method_argument_names)
-      module_type = get_module_type(context_params)
+    def import_git_module_aux(context_params)
+      # For Aldin
+      # This would now be one top level call
+      # uncomment this out to se simple example 
+      # CommonModule::Import.new(self,context_params).from_git()
 
+      git_repo_url, module_name    = context_params.retrieve_arguments([:option_1!, :option_2!], method_argument_names)
       namespace, local_module_name = get_namespace_and_name(module_name, ModuleUtil::NAMESPACE_SEPERATOR)
 
-      # Create component module from user's input git repo
+      module_type  = get_module_type(context_params)
+      thor_options = { :git_import => true}
+
+      unless namespace
+        resp = post rest_url("namespace/default_namespace_name")
+        return resp unless resp.ok?
+
+        namespace = resp.data
+        thor_options[:default_namespace] = namespace
+      end
+
       opts = {
         :namespace => namespace,
-        :branch  => options['branch']
+        :branch    => options['branch']
       }
       response = Helper(:git_repo).create_clone_from_optional_branch(module_type.to_sym, local_module_name, git_repo_url, opts)
-
-      # Raise error if git repository is invalid
-      # raise DtkError,"Git repository URL '#{git_repo_url}' is invalid." unless response.ok?
       return response unless response.ok?
 
       # Remove .git directory to rid of git pointing to user's github
       FileUtils.rm_rf("#{response['data']['module_directory']}/.git")
 
-      context_params.forward_options({:git_import => true})
-      # Reuse module create method to create module from local component_module
-      create_response = import(context_params)
+      context_params.forward_options(thor_options)
+      create_response = import_module_aux(context_params)
 
       if create_response.ok?
         if external_dependencies = create_response.data(:external_dependencies)
-          inconsistent = external_dependencies["inconsistent"]
-          possibly_missing = external_dependencies["possibly_missing"]
-          OsUtil.print("There are some inconsistent dependencies: #{inconsistent}", :red) unless inconsistent.empty?
-          OsUtil.print("There are some missing dependencies: #{possibly_missing}", :yellow) unless possibly_missing.empty?
+          inconsistent = external_dependencies["inconsistent"]||[]
+          possibly_missing = external_dependencies["possibly_missing"]||[]
+          ambiguous = external_dependencies["ambiguous"]||[]
+          amb_sorted = ambiguous.map { |k,v| "#{k.split('/').last} (#{v.join(', ')})" }
+          OsUtil.print("There are inconsistent module dependencies mentioned in the git repo: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
+          OsUtil.print("There are missing module dependencies mentioned in the git repo: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+          OsUtil.print("There are ambiguous module dependencies mentioned in the git repo: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) if ambiguous && !ambiguous.empty?
         end
       else
-        local_module_name = create_response.data[:full_module_name] if create_response.data[:full_module_name]
+        delete_dir        = namespace.nil? ? local_module_name : "#{namespace}/#{local_module_name}"
+        full_module_name  = create_response.data[:full_module_name]
+        local_module_name = full_module_name.nil? ? delete_dir : full_module_name
         delete_module_sub_aux(context_params, local_module_name, :force_delete => true, :no_error_msg => true, :purge => true)
         return create_response
       end
 
       Response::Ok.new()
     end
-
     def import_module_aux(context_params)
-      git_import  = context_params.get_forwarded_options()[:git_import] if context_params.get_forwarded_options()
+      # CommonModule::Import.new(self,context_params).from_file()
+      if context_params.get_forwarded_options()
+        default_ns = context_params.get_forwarded_options()[:default_namespace]
+        git_import = context_params.get_forwarded_options()[:git_import]
+      end
+
       name_option = git_import ? :option_2! : :option_1!
       module_name = context_params.retrieve_arguments([name_option],method_argument_names)
       module_type = get_module_type(context_params)
+      version     = options["version"]
+      opts        = {}
 
+      # extract namespace and module_name from full name (r8:maven will result in namespace = r8 & name = maven)
       namespace, local_module_name = get_namespace_and_name(module_name, ModuleUtil::NAMESPACE_SEPERATOR)
+      namespace = default_ns if default_ns && namespace.nil?
+
       # first check that there is a directory there and it is not already a git repo, and it ha appropriate content
       response = Helper(:git_repo).check_local_dir_exists_with_content(module_type.to_sym, local_module_name, nil, namespace)
       return response unless response.ok?
-      module_directory = response.data(:module_directory)
 
       #check for yaml/json parsing errors before import
+      module_directory = response.data(:module_directory)
       reparse_aux(module_directory)
 
       # first make call to server to create an empty repo
-      response = post rest_url("#{module_type}/create"), { :module_name => local_module_name, :module_namespace => namespace }
+      post_body = {
+        :module_name => local_module_name,
+        :module_namespace => namespace
+      }
+      response = post(rest_url("#{module_type}/create"), post_body)
       return response unless response.ok?
 
-      repo_url,repo_id,module_id,branch,new_module_name = response.data(:repo_url,:repo_id,:module_id,:workspace_branch,:full_module_name)
+      repo_url,repo_id,module_id,branch,new_module_name = response.data(:repo_url, :repo_id, :module_id, :workspace_branch, :full_module_name)
       response = Helper(:git_repo).rename_and_initialize_clone_and_push(module_type.to_sym, local_module_name, new_module_name, branch, repo_url, module_directory)
       return response unless (response && response.ok?)
 
-      repo_obj,commit_sha = response.data(:repo_obj, :commit_sha)
-      module_final_dir = repo_obj.repo_dir
-      old_dir = response.data[:old_dir]
+      repo_obj, commit_sha = response.data(:repo_obj, :commit_sha)
+      module_final_dir     = repo_obj.repo_dir
+      old_dir              = response.data[:old_dir]
 
       post_body = {
-        :repo_id => repo_id,
-        "#{module_type}_id".to_sym => module_id,
+        :repo_id    => repo_id,
         :commit_sha => commit_sha,
-        :scaffold_if_no_dsl => true
+        :commit_dsl => true,
+        :scaffold_if_no_dsl => true,
+        "#{module_type}_id".to_sym => module_id
       }
-      response = post(rest_url("#{module_type}/update_from_initial_create"),post_body)
+      post_body.merge!(:git_import => true) if git_import
+      response = post(rest_url("#{module_type}/update_from_initial_create"), post_body)
+
+      if error = response.data(:dsl_parse_error)
+        dsl_parsed_message = ServiceImporter.error_message(module_name, error)
+        DTK::Client::OsUtil.print(dsl_parsed_message, :red)
+      end
 
       unless response.ok?
         response.set_data_hash({ :full_module_name => new_module_name })
@@ -264,43 +337,99 @@ module DTK::Client
         return response
       end
 
+      dsl_updated_info      = response.data(:dsl_updated_info)
+      dsl_created_info      = response.data(:dsl_created_info)
       external_dependencies = response.data(:external_dependencies)
-      dsl_created_info = response.data(:dsl_created_info)
+      DTK::Client::OsUtil.print("A module_refs.yaml file has been created for you, located at #{module_final_dir}", :yellow) if dsl_updated_info && !dsl_updated_info.empty?
+      DTK::Client::OsUtil.print("A #{dsl_created_info["path"]} file has been created for you, located at #{module_final_dir}", :yellow) if dsl_created_info && !dsl_created_info.empty?
 
-      if dsl_created_info and !dsl_created_info.empty?
-        msg = "A #{dsl_created_info["path"]} file has been created for you, located at #{module_final_dir}"
-        DTK::Client::OsUtil.print(msg,:yellow)
-        response = Helper(:git_repo).add_file(repo_obj, dsl_created_info["path"], dsl_created_info["content"], msg)
-        return response unless response.ok?
-      end
+      module_name, module_namespace, repo_url, branch, not_ok_response = workspace_branch_info(module_type, module_id, version)
+      return not_ok_response if not_ok_response
 
-      #TODO: this is never used
-      response = Response::Ok.new("module_created" => module_name)
+      opts_pull = {
+        :local_branch => branch,
+        :namespace => module_namespace
+      }
 
-      # TODO: what is purpose of pushing again
-      # we push clone changes anyway, user can change and push again
-      # context_params.add_context_to_params(module_name, :"component-module", module_id)
-      context_params.add_context_to_params(local_module_name, module_type.to_s.gsub!(/\_/,'-').to_sym, module_id)
-      response = push_module_aux(context_params, true)
+      # if import-git then always pull changes because files are created on server side
+      if git_import
+        resp = Helper(:git_repo).pull_changes(module_type, module_name, opts_pull)
+        return resp unless resp.ok?
+        response[:module_id] = module_id
+      else
+        # For Aldin; I think all code below this is just for import for file; so think we reorganize to have evrything above this be a common
+        # routine called by both; and then put in new method for 'import from file' that calss common , whcih passes back response
+        # and then calls the rest in the 'import from file' body
+
+        # since we are creating module_refs and dtk,,odel.yaml files on server need to pull
+        dsl_updated_info = response.data(:dsl_updated_info)
+        if dsl_updated_info and !dsl_updated_info.empty?
+          new_commit_sha = dsl_updated_info[:commit_sha]
+          unless new_commit_sha and new_commit_sha == commit_sha
+            resp = Helper(:git_repo).pull_changes(module_type, module_name, opts_pull)
+            return resp unless resp.ok?
+          end
+        end
 
-      unless response.ok?
-        # remove new directory and leave the old one if import without namespace failed
+        # For Aldin; wil update the server side to  have dsl_created_info not have content when that is added on server side
+        # so setting acondition wrt to this and casing on this, i.e., whether need to commit file and then do push
+        # after we make sure working we can remove code that commits dsl file on client side
+        push_needed = false
+        if dsl_created_info and !dsl_created_info.empty?
+          path = dsl_created_info["path"]
+          msg = "A #{path} file has been created for you, located at #{module_final_dir}"
+          if content = dsl_created_info["content"]
+            resp = Helper(:git_repo).add_file(repo_obj, path, content, msg)
+            return resp unless resp.ok?
+            push_needed = true
+          end
+        end
+
+        ##### code that does push that can be removed once we always do commit of dsl on server side
+        if push_needed
+          if external_dependencies
+            ambiguous        = external_dependencies['ambiguous']||[]
+            possibly_missing = external_dependencies["possibly_missing"]||[]
+            opts.merge!(:set_parsed_false => true, :skip_module_ref_update => true) unless ambiguous.empty? && possibly_missing.empty?
+          end
+          
+          context_params.add_context_to_params(local_module_name, module_type.to_s.gsub!(/\_/,'-').to_sym, module_id)
+          response = push_module_aux(context_params, true, opts)
+
+          if error = response.data(:dsl_parse_error)
+            dsl_parsed_message = ServiceImporter.error_message(module_name, error)
+            DTK::Client::OsUtil.print(dsl_parsed_message, :red)
+          end
+          
+          unless response.ok?
+            # remove new directory and leave the old one if import without namespace failed
+            if old_dir and (old_dir != module_final_dir)
+              FileUtils.rm_rf(module_final_dir) unless namespace
+            end
+            return response
+          end
+        end
+        ##### end: code that does push  
+
+        response = Response::Ok.new()
+ 
+        # remove source directory if no errors while importing
         if old_dir and (old_dir != module_final_dir)
-          FileUtils.rm_rf(module_final_dir) unless (namespace && git_import)
+          FileUtils.rm_rf(old_dir) unless namespace
         end
-        return response
-      end
 
-      # remove source directory if no errors while importing
-      if old_dir and (old_dir != module_final_dir)
-        FileUtils.rm_rf(old_dir) unless (namespace && git_import)
-      end
+        # For Aldin: need to also check to see if any parsing errors by looking at what is now in response under dsl_parse_error
+        # (it was just renamed from dsl_parse_info)
 
-      if git_import
-        response[:module_id] = module_id
-        response.add_data_value!(:external_dependencies, external_dependencies) if external_dependencies
-      else
-        # if not git-import and user do import from default directory (e.g. import ntp - without namespace) print message
+        if external_dependencies
+          ambiguous        = external_dependencies["ambiguous"]||[]
+          amb_sorted       = ambiguous.map { |k,v| "#{k.split('/').last} (#{v.join(', ')})" }
+          possibly_missing = external_dependencies["possibly_missing"]||[]
+          OsUtil.print("There are missing module dependencies in dtk.model.yaml includes: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+          OsUtil.print("There are ambiguous module dependencies in dtk.model.yaml includes: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) unless ambiguous.empty?
+        end
+
+        # if user do import from default directory (e.g. import ntp - without namespace) print message
         # module directory moved from (~/dtk/component_module/<module_name>) to (~/dtk/component_module/<default_namespace>/<module_name>)
         DTK::Client::OsUtil.print("Module '#{new_module_name}' has been created and module directory moved to #{module_final_dir}",:yellow) unless namespace
       end
@@ -370,7 +499,7 @@ module DTK::Client
       # module_name,repo_url,branch,version = response.data(:module_name, :repo_url, :workspace_branch, :version)
       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_parsed_info)
+      if error = response.data(:dsl_parse_error)
         dsl_parsed_message = ServiceImporter.error_message(module_name, error)
         DTK::Client::OsUtil.print(dsl_parsed_message, :red)
       end
@@ -572,6 +701,12 @@ module DTK::Client
       end
     end
 
+    def list_remote_module_diffs(context_params)
+      module_type = get_module_type(context_params)
+      module_id   = context_params.retrieve_arguments([REQ_MODULE_ID],method_argument_names)
+      list_remote_diffs_aux(module_type.to_sym, module_id)
+    end
+
     def delete_assembly_aux(context_params)
       module_type = get_module_type(context_params)
 
@@ -636,5 +771,8 @@ module DTK::Client
       response.render_table(:assembly)
     end
 
+    def print_ambiguous(ambiguous)
+    end
+
   end
 end

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

@@ -89,7 +89,7 @@ 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].empty?
+        if (response.data[:diffs].nil? || response.data[:diffs].empty?)
           puts "No changes to pull from remote."
         else
           puts "Changes pulled from remote"

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

@@ -0,0 +1,51 @@
+module DTK::Client
+  module PuppetForgeMixin
+
+    def puppet_forge_install_aux(context_params, pf_module_name, module_name, namespace, version, module_type)
+      post_body_hash = {
+        :puppetf_module_name => pf_module_name,
+        :module_name?        => module_name,
+        :module_version?     => version,
+        :module_namespace?   => namespace
+      }
+
+      response = post rest_url("component_module/install_puppet_forge_modules"),PostBody.new(post_body_hash)
+
+      return response unless response.ok?
+
+
+      installed_modules = response.data(:installed_modules)
+
+      print_modules(response.data(:found_modules), 'using')
+      print_modules(installed_modules, 'installed')
+
+      main_module = response.data(:main_module)
+
+      unless installed_modules.empty?
+        # clone_deps = Console.confirmation_prompt("\nDo you want to clone newly installed dependencies?")
+        # if clone_deps
+        installed_modules.each do |im|
+          clone_aux(im['type'], im['id'], im['version'], true, true, {:backup_if_exist => true})
+        end
+        # end
+      end
+
+      clone_aux(main_module['type'], main_module['id'], main_module['version'], true, true, {:print_imported => true, :backup_if_exist => true})
+      nil
+  end
+
+    private
+
+    def print_modules(modules, action_name)
+      modules.each do |target_module|
+        module_name = full_module_name(target_module)
+        module_type = target_module['type']
+
+        print "#{action_name.capitalize} dependency #{module_type.gsub('_',' ')} '#{module_name}'\n"
+      end
+    end
+
+  end
+end
+
+

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

@@ -8,42 +8,52 @@ module DTK::Client
     #
     # module_type: will be :component_module or :service_module
     def push_clone_changes_aux(module_type,module_id,version,commit_msg,internal_trigger=false,opts={})
-      module_name,module_namespace,repo_url,branch,not_ok_response = workspace_branch_info(module_type,module_id,version,opts)
+      module_name, module_namespace, repo_url, branch, not_ok_response = workspace_branch_info(module_type, module_id, version, opts)
       return not_ok_response if not_ok_response
 
       full_module_name = ModuleUtil.resolve_name(module_name, module_namespace)
-      module_location  = OsUtil.module_location(module_type,full_module_name,version,opts)
+      module_location  = OsUtil.module_location(module_type, full_module_name, version, opts)
 
       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"+'?')
-          clone_aux(module_type,module_id, version, true, true, opts)
+          clone_aux(module_type, module_id, version, true, true, opts)
         else
           return
         end
       end
 
       push_opts = opts.merge(:commit_msg => commit_msg, :local_branch => branch)
-      response = Helper(:git_repo).push_changes(module_type,full_module_name,version,push_opts)
+      response  = Helper(:git_repo).push_changes(module_type, full_module_name, version, push_opts)
       return response unless response.ok?
 
       json_diffs = (response.data(:diffs).empty? ? {} : JSON.generate(response.data(:diffs)))
       commit_sha = response.data(:commit_sha)
-      repo_obj = response.data(:repo_obj)
+      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  = 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']
+      post_body.merge!(:force_parse => true) if options['force-parse'] || opts[:force_parse]
+      post_body.merge!(:skip_module_ref_update => true) if opts[:skip_module_ref_update]
+      post_body.merge!(:update_from_includes => true) if opts[:update_from_includes]
 
-      response = post(rest_url("#{module_type}/update_model_from_clone"),post_body)
+      if opts[:set_parsed_false]
+        post_body.merge!(:set_parsed_false => true)
+        post_body.merge!(:force_parse => true)
+      end
+
+      response = post(rest_url("#{module_type}/update_model_from_clone"), post_body)
       return response unless response.ok?
 
       ret = Response::Ok.new()
+      external_dependencies = response.data('external_dependencies')
 
       # check if any errors
-      if dsl_parsed_info = response.data(:dsl_parsed_info)
-        if dsl_parsed_message = ServiceImporter.error_message(module_name, dsl_parsed_info)
-          DTK::Client::OsUtil.print(dsl_parsed_message, :red)
+      if dsl_parse_error = response.data(:dsl_parse_error)
+        if parsed_external_dependencies = dsl_parse_error['external_dependencies']
+          external_dependencies = parsed_external_dependencies
+        elsif err_message = ServiceImporter.error_message(module_name, dsl_parse_error)
+          DTK::Client::OsUtil.print(err_message, :red)
           ret = Response::NoOp.new()
         end
       end
@@ -57,8 +67,20 @@ module DTK::Client
         new_commit_sha = dsl_updated_info[:commit_sha]
         unless new_commit_sha and new_commit_sha == commit_sha
           opts_pull = opts.merge(:local_branch => branch,:namespace => module_namespace)
-          response = Helper(:git_repo).pull_changes(module_type,module_name,opts_pull)
-          return response unless response.ok?
+          resp = Helper(:git_repo).pull_changes(module_type, module_name, opts_pull)
+          return resp unless resp.ok?
+        end
+      end
+
+      if opts[:print_dependencies] || !internal_trigger
+        if external_dependencies
+          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: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
+          OsUtil.print("There are missing module dependencies: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+          OsUtil.print("There are ambiguous module dependencies: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) if ambiguous && !ambiguous.empty?
         end
       end
 
@@ -68,12 +90,28 @@ module DTK::Client
         path = dsl_created_info["path"]
         content = dsl_created_info["content"]
         if path and content
-          msg = "A #{path} file has been created for you, located at #{repo_obj.repo_dir}"
+          msg      = "A #{path} file has been created for you, located at #{repo_obj.repo_dir}"
           response = Helper(:git_repo).add_file(repo_obj,path,content,msg)
           return response unless response.ok?
         end
       end
+
+      service_component_refs = response.data['component_module_refs']
+      unless (service_component_refs||{}).empty?
+        print_using_dependencies(service_component_refs)
+      end
+
       ret
     end
+
+    private
+    def print_using_dependencies(component_refs)
+      component_refs.each do |k, value|
+        namespace = value['namespace_info']
+        name      = value['module_name']
+        puts "Using component module '#{namespace}:#{name}'"
+      end
+    end
+
   end
 end

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

@@ -1,32 +1,18 @@
-require 'json'
 require 'yaml'
 
 module DTK::Client
   module ReparseMixin
+    YamlDTKMetaFiles = ['dtk.model.yaml', 'module_refs.yaml', 'assemblies/*.yaml', 'assemblies/*/assembly.yaml']
 
-    ##
-    #
-    # module_type: will be :component_module or :service_module
     def reparse_aux(location)
-      files_json = Dir.glob("#{location}/**/*.json")
-      files_yaml = Dir.glob("#{location}/**/*.yaml")
-
-      files_json.each do |file|
-        file_content = File.open(file).read
-        begin 
-          JSON.parse(file_content)
-        rescue JSON::ParserError => e
-          raise DTK::Client::DSLParsing::JSONParsing.new("JSON parsing error #{e} in file",file)
-        end
-      end
-
+      files_yaml = YamlDTKMetaFiles.map{|rel_path|Dir.glob("#{location}/#{rel_path}")}.flatten(1)
       files_yaml.each do |file|
         file_content = File.open(file).read
         begin 
           YAML.load(file_content)
         rescue Exception => e
           e.to_s.gsub!(/\(<unknown>\)/,'')
-          raise DTK::Client::DSLParsing::YAMLParsing.new("YAML parsing error #{e} in file",file)
+          raise DTK::Client::DSLParsing::YAMLParsing.new("YAML parsing error #{e} in file", file)
         end
       end
       
@@ -34,4 +20,4 @@ module DTK::Client
     end
 
   end
-end
+end

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

@@ -22,16 +22,20 @@ module DTK::Client
                 #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
+                # 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')