dtk-client 0.5.17 → 0.5.18

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

@@ -106,12 +106,72 @@ module DTK::Client
       Response::Ok.new()
     end
 
+    # returns text string with edited yaml content
+    def attributes_editor(yaml_input)
+      dtk_folder = OsUtil.dtk_local_folder
+      file_path = "#{dtk_folder}/temp_attrs.yaml"
+      File.open(file_path, 'w'){|f| f << yaml_input}
+      OsUtil.edit(file_path)
+      OsUtil.print("If you want to use different editor please set environment variable EDITOR and log back into dtk-shell!", :yellow) unless ENV['EDITOR']
+      edited_yaml = File.open(file_path,'r'){|f|f.read}
+      File.unlink(file_path)
+      edited_yaml
+    end
+   private
+    # removes any nil values and returns hash; also modifies any term that does not serialize
+    def post_process(object)
+      ret = Hash.new
+      if object.kind_of?(Hash)
+        post_process__hash(object)
+      elsif object.kind_of?(Array)
+        post_process__array(object)
+      elsif object.kind_of?(FalseClass)
+        Response::Term::Boolean.false
+      else
+        object
+      end
+    end
+
+    def post_process__hash(hash)
+      ret = Hash.new
+      hash.each_pair do |k,v|
+        processed_val = post_process(v)
+        #processed_val can be false so explicitly checking against nil
+        unless processed_val.nil?
+          ret.merge!(k => processed_val)
+        end 
+      end
+      ret
+    end
+
+    def post_process__array(array)
+      ret = Array.new
+      array.each do |a|
+        # explicit nil not removed
+        if a.nil? 
+          ret << Response::Term.nil()
+        else
+          processed_val = post_process(a)
+          #processed_val can be false so explicitly checking against nil
+          unless processed_val.nil?
+            ret << processed_val
+          end
+        end
+      end
+      ret
+    end
+  end
+end
+
+
+=begin
+    # TODO: probably deprecate
     def attribute_header()
       header_string = 
       "#############################\n####  REQUIRED ATTRIBUTES\n#############################\n#\n"
     end
-
-    def attributes_editor(attributes,format)
+    # TODO: probably deprecate
+    def attributes_editor_old_form(attributes,format)
       if (format.eql?('yaml'))
         dtk_folder = OsUtil.dtk_local_folder
         file_path = "#{dtk_folder}/temp_attrs.yaml"
@@ -153,7 +213,7 @@ module DTK::Client
         begin
           edited = YAML.load_file(file_path)
         rescue Psych::SyntaxError => e
-          raise DTK::Client::DSLParsing::YAMLParsing.new("YAML parsing error #{e} in file",file_path)
+          raise DSLParsing::YAMLParsing.new("YAML parsing error #{e} in file",file_path)
         end
 
         edited.each do |k,v|
@@ -169,9 +229,8 @@ module DTK::Client
         raise DtkValidationError, "No attribute changes have been made." if ((first_iteration_keys == second_iteration_keys) && (first_iteration_values == second_iteration_values))
         edited
       else
-        raise DTK::Client::DtkValidationError, "Unsupported format type '#{format.to_s}'!"
+        raise DtkValidationError, "Unsupported format type '#{format.to_s}'!"
       end
     end
+=end
 
-  end
-end

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

@@ -15,8 +15,9 @@ module DTK::Client
 
       response = post(rest_url("#{module_type}/get_remote_module_info"),post_body)
       return response unless response.ok?
-      
-      module_name = response.data(:module_name)
+
+      module_name = response.data(:full_module_name)
+
       opts = {
         :remote_repo_url => response.data(:remote_repo_url),
         :remote_repo => response.data(:remote_repo),
@@ -31,7 +32,7 @@ module DTK::Client
       added, deleted, modified = print_diffs(response.data(remote ? :diffs : :status), remote)
 
       raise DTK::Client::DtkValidationError, "There is no changes in current workspace!" if(added.empty? && deleted.empty? && modified.empty?)
-      
+
       unless added.empty?
         puts "ADDED:"
         added.each do |a|

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

@@ -30,11 +30,19 @@ module DTK::Client
     include ServiceImporter
     include AccessControlMixin
 
-    REQ_MODULE_ID = [:service_module_id!, :component_module_id!, :test_module_id!]
+    REQ_MODULE_ID   = [:service_module_id!, :component_module_id!, :test_module_id!]
+    REQ_MODULE_NAME = [:service_module_name!, :component_module_name!, :test_module_name!]
 
     def get_module_type(context_params)
-      forwarded_type = context_params.get_forwarded_options() ? context_params.get_forwarded_options()[:module_type] : ''
-      module_type = (context_params.root_command_name||forwarded_type).gsub(/\-/, "_")
+      forwarded_type = context_params.get_forwarded_options() ? context_params.get_forwarded_options()[:module_type] : nil
+
+      if context_params.root_command_name || forwarded_type
+        module_type = (context_params.root_command_name||forwarded_type).gsub(/\-/, "_")
+      else
+        module_type = resolve_module_type
+      end
+
+      module_type
     end
 
     def module_info_about(context_params, about, data_type)
@@ -68,25 +76,26 @@ module DTK::Client
       end
     end
 
-    def delete_module_aux(context_params,method_opts={})
+    def delete_module_aux(context_params, method_opts={})
       module_location, modules_path = nil, nil
       module_id = context_params.retrieve_arguments([:option_1!], method_argument_names)
+
+      delete_module_sub_aux(context_params, module_id, method_opts)
+    end
+
+    def delete_module_sub_aux(context_params, module_id, method_opts={})
+      # ModuleUtil.check_format!(module_id)
       version = options.version
       module_name = get_name_from_id_helper(module_id)
       module_type = get_module_type(context_params)
 
-      # if called from import-git first param will be git_url and second one will be module_id
-      git_import = context_params.get_forwarded_options()[:git_import] if context_params.get_forwarded_options()
-      if git_import
-        module_id = context_params.retrieve_arguments([:option_2!], method_argument_names)
-      end
-
       unless (options.force? || method_opts[:force_delete])
-        return unless Console.confirmation_prompt("Are you sure you want to delete #{module_type} #{version.nil? ? '' : 'version '}'#{module_name}#{version.nil? ? '' : ('-' + version.to_s)}' and all items contained in it"+'?')
+        is_go = Console.confirmation_prompt("Are you sure you want to delete module '#{module_name}'"+"?")
+        return nil unless is_go
       end
 
       response =
-        if options.purge?
+        if options.purge? || method_opts[:purge]
           opts = {:module_name => module_name}
           if version then opts.merge!(:version => version)
           else opts.merge!(:delete_all_versions => true)
@@ -142,13 +151,7 @@ module DTK::Client
       module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID, "#{module_type}_name".to_sym],method_argument_names)
       version = options["version"]
 
-      if module_name.to_s =~ /^[0-9]+$/
-        module_id   = module_name
-        module_name = get_name_from_id_helper(module_id)
-      end
-
-      modules_path    = OsUtil.module_clone_location(module_type)
-      module_location = "#{modules_path}/#{module_name}#{version && "-#{version}"}"
+      module_location = OsUtil.module_location(module_type, module_name, version)
 
       reparse_aux(module_location)
       push_clone_changes_aux(module_type.to_sym, module_id, version, options["message"]||DEFAULT_COMMIT_MSG, internal_trigger)
@@ -162,13 +165,17 @@ module DTK::Client
       return response unless response.ok?
 
       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" }
         if error_msg.empty?
           # If server response is not ok and module does not exist on server, delete cloned module, invoke delete method
-          FileUtils.rm_rf("#{response['data']['module_directory']}")
           delete(context_params,:force_delete => true, :no_error_msg => true)
         end
+
+        # remove temp directory
+        FileUtils.rm_rf("#{response['data']['module_directory']}")
+
         return create_response
       end
     end
@@ -177,8 +184,10 @@ module DTK::Client
       git_repo_url, module_name = context_params.retrieve_arguments([:option_1!, :option_2!],method_argument_names)
       module_type = get_module_type(context_params)
 
+      namespace, local_module_name = get_namespace_and_name(module_name, ModuleUtil::NAMESPACE_SEPERATOR)
+
       # Create component module from user's input git repo
-      response = Helper(:git_repo).create_clone_with_branch(module_type.to_sym, module_name, git_repo_url)
+      response = Helper(:git_repo).create_clone_with_branch(module_type.to_sym, local_module_name, git_repo_url)
 
       # Raise error if git repository is invalid
       # raise DtkError,"Git repository URL '#{git_repo_url}' is invalid." unless response.ok?
@@ -199,9 +208,7 @@ module DTK::Client
           OsUtil.print("There are some missing dependencies: #{possibly_missing}", :yellow) unless possibly_missing.empty?
         end
       else
-        # If server response is not ok, delete cloned module, invoke delete method
-        FileUtils.rm_rf("#{response['data']['module_directory']}")
-        delete(context_params,:force_delete => true, :no_error_msg => true)
+        delete_module_sub_aux(context_params, local_module_name, :force_delete => true, :no_error_msg => true, :purge => true)
         return create_response
       end
 
@@ -214,8 +221,9 @@ module DTK::Client
       module_name = context_params.retrieve_arguments([name_option],method_argument_names)
       module_type = get_module_type(context_params)
 
+      namespace, local_module_name = get_namespace_and_name(module_name, ModuleUtil::NAMESPACE_SEPERATOR)
       # 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, module_name)
+      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)
 
@@ -223,14 +231,14 @@ module DTK::Client
       reparse_aux(module_directory)
 
       # first make call to server to create an empty repo
-      response = post rest_url("#{module_type}/create"), { :module_name => module_name }
+      response = post rest_url("#{module_type}/create"), { :module_name => local_module_name, :module_namespace => namespace }
       return response unless response.ok?
 
-      repo_url,repo_id,module_id,branch = response.data(:repo_url,:repo_id,:module_id,:workspace_branch)
-      response = Helper(:git_repo).initialize_client_clone_and_push(module_type.to_sym, module_name, branch, repo_url, module_directory)
-
+      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.ok?
       repo_obj,commit_sha =  response.data(:repo_obj, :commit_sha)
+      module_final_dir = repo_obj.repo_dir
 
       post_body = {
         :repo_id => repo_id,
@@ -239,21 +247,29 @@ module DTK::Client
         :scaffold_if_no_dsl => true
       }
       response = post(rest_url("#{module_type}/update_from_initial_create"),post_body)
-      return response unless response.ok?
+
+      unless response.ok?
+        response.set_data_hash({ :full_module_name => new_module_name })
+        return response
+      end
 
       external_dependencies = response.data(:external_dependencies)
       dsl_created_info = response.data(:dsl_created_info)
 
       if dsl_created_info and !dsl_created_info.empty?
-        msg = "A #{dsl_created_info["path"]} file has been created for you, located at #{module_directory}"
+        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)
-      else
-        response = Response::Ok.new("module_created" => module_name)
+        return response unless response.ok?
       end
 
+      #TODO: this is never used
+      response = Response::Ok.new("module_created" => module_name)
+
+      # 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(module_name, module_type.to_s.gsub!(/\_/,'-').to_sym, 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 git_import
@@ -261,7 +277,7 @@ module DTK::Client
         response.add_data_value!(:external_dependencies, external_dependencies) if external_dependencies
       end
 
-      return response
+      response
     end
 
     def install_module_aux(context_params)
@@ -277,8 +293,9 @@ module DTK::Client
       ignore_component_error = context_params.get_forwarded_options() ? context_params.get_forwarded_options()[:ignore_component_error] : options.ignore?
       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)
-      if clone_dir = Helper(:git_repo).local_clone_dir_exists?(module_type.to_sym, local_module_name, version)
+      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
 
@@ -299,11 +316,12 @@ module DTK::Client
 
       # case when we need to import additional components
       if (response.ok? && (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)
         module_opts.merge!(:module_type => 'component-module')
 
-        continue = trigger_module_component_import(missing_components,module_opts)
+        continue = trigger_module_component_import(missing_components, required_components, module_opts)
         return unless continue
 
         puts "Resuming DTK Network import for #{module_type} '#{remote_module_name}' ..."
@@ -315,14 +333,14 @@ module DTK::Client
       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)
       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)
         dsl_parsed_message = ServiceImporter.error_message(module_name, error)
         DTK::Client::OsUtil.print(dsl_parsed_message, :red)
       end
 
       unless skip_cloning
-        response = Helper(:git_repo).create_clone_with_branch(module_type.to_sym, module_name, repo_url, branch, version)
+        response = Helper(:git_repo).create_clone_with_branch(module_type.to_sym, module_name, repo_url, branch, version, remote_namespace)
       end
 
       resolve_missing_components(module_id, module_name, namespace, options.force?) if module_type.to_s.eql?('service_module')
@@ -334,7 +352,7 @@ module DTK::Client
       remote_module_name = context_params.retrieve_arguments([:option_1!],method_argument_names)
 
       # for service_module we are doing this on server side
-      remote_namespace, remote_module_name = get_namespace_and_name(remote_module_name) unless module_type.eql?('service_module')
+      remote_namespace, remote_module_name = get_namespace_and_name(remote_module_name,'/') unless module_type.eql?('service_module')
 
       unless options.force?
         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"+'?')
@@ -367,20 +385,15 @@ module DTK::Client
     end
 
     def pull_dtkn_aux(context_params)
-      module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID,:component_module_name,:option_1],method_argument_names)
+      module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID,REQ_MODULE_NAME,:option_1],method_argument_names)
+
       catalog      = 'dtkn'
       version      = options["version"]
       module_type  = get_module_type(context_params)
 
       raise DtkValidationError, "You have to provide valid catalog to pull changes from! Valid catalogs: #{PULL_CATALOGS}" unless catalog
 
-      if module_name.to_s =~ /^[0-9]+$/
-        module_id = module_name
-        module_name = get_name_from_id_helper(module_id)
-      end
-
-      modules_path    = OsUtil.module_clone_location(module_type)
-      module_location = "#{modules_path}/#{module_name}#{version && "-#{version}"}"
+      module_location = OsUtil.module_location(resolve_module_type(), module_name, version)
 
       if catalog.to_s.eql?("dtkn")
         clone_aux(module_type.to_sym, module_id, version, true, true) unless File.directory?(module_location)
@@ -438,14 +451,7 @@ module DTK::Client
       version          = thor_options["version"]
       internal_trigger = true if thor_options['skip_edit']
 
-      # if this is not name it will not work, we need module name
-      if module_name.to_s =~ /^[0-9]+$/
-        module_id   = module_name
-        module_name = get_name_from_id_helper(module_id)
-      end
-
-      modules_path    = OsUtil.module_clone_location(module_type)
-      module_location = "#{modules_path}/#{module_name}#{version && "-#{version}"}"
+      module_location = OsUtil.module_location(module_type, module_name, version)
 
       raise DTK::Client::DtkValidationError, "Trying to clone a #{module_type} '#{module_name}#{version && "-#{version}"}' that exists already!" if File.directory?(module_location)
       clone_aux(module_type.to_sym, module_id, version, internal_trigger, thor_options['omit_output'])
@@ -458,12 +464,6 @@ module DTK::Client
       version     = options.version||context_params.retrieve_arguments([:option_1], method_argument_names)
       edit_dsl    = context_params.get_forwarded_options()[:edit_dsl] if context_params.get_forwarded_options()
 
-      # if this is not name it will not work, we need module name
-      if module_name.to_s =~ /^[0-9]+$/
-        module_id   = module_name
-        module_name = get_name_from_id_helper(module_id)
-      end
-
       #TODO: cleanup so dont need :base_file_name and get edit_file from server
       opts = {}
       base_file_name = "dtk.model"
@@ -472,21 +472,15 @@ module DTK::Client
     end
 
     def push_dtkn_module_aux(context_params, internal_trigger=false)
-#      component_module_id, component_module_name, catalog = context_params.retrieve_arguments([:component_module_id!, :component_module_name, :option_1],method_argument_names)
-      module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID, :component_module_name],method_argument_names)
+      module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID, REQ_MODULE_NAME],method_argument_names)
       catalog     = 'dtkn'
       version     = options["version"]
       module_type = get_module_type(context_params)
 
       raise DtkValidationError, "You have to provide valid catalog to push changes to! Valid catalogs: #{PushCatalogs}" unless catalog
 
-      if module_name.to_s =~ /^[0-9]+$/
-        module_id   = module_name
-        module_name = get_name_from_id_helper(module_id)
-      end
+      module_location = OsUtil.module_location(resolve_module_type(), module_name, version)
 
-      modules_path    = OsUtil.module_clone_location(module_type)
-      module_location = "#{modules_path}/#{module_name}#{version && "-#{version}"}"
       reparse_aux(module_location) unless internal_trigger
 
 #      if catalog.to_s.eql?("origin")
@@ -520,14 +514,7 @@ module DTK::Client
       module_name = context_params.retrieve_arguments(["#{module_type}_name".to_sym],method_argument_names)
       version     = options["version"]
 
-      # if this is not name it will not work, we need module name
-      if module_name.to_s =~ /^[0-9]+$/
-        module_id   = module_name
-        module_name = get_name_from_id_helper(module_id)
-      end
-
-      modules_path    = OsUtil.module_clone_location(module_type)
-      module_location = "#{modules_path}/#{module_name}#{version && "-#{version}"}"
+      module_location = OsUtil.module_location(module_type, module_name, version)
 
       # check if there is repository cloned
       if File.directory?(module_location)
@@ -550,14 +537,10 @@ module DTK::Client
       module_type = get_module_type(context_params)
       module_id, assembly_template_id = context_params.retrieve_arguments([REQ_MODULE_ID,:option_1!], method_argument_names)
       module_name = context_params.retrieve_arguments([:service_module_name],method_argument_names)
+
       assembly_template_name = (assembly_template_id.to_s =~ /^[0-9]+$/) ? DTK::Client::Assembly.get_assembly_template_name_for_service(assembly_template_id, module_name) : assembly_template_id
       assembly_template_id   = DTK::Client::Assembly.get_assembly_template_id_for_service(assembly_template_id, module_name) unless assembly_template_id.to_s =~ /^[0-9]+$/
 
-      if module_name.to_s =~ /^[0-9]+$/
-        module_id   = module_name
-        module_name = get_name_from_id_helper(module_id)
-      end
-
       return unless Console.confirmation_prompt("Are you sure you want to delete assembly '#{assembly_template_name||assembly_template_id}'"+'?') unless options.force?
 
       post_body = {
@@ -566,13 +549,27 @@ module DTK::Client
         :subtype => :template
       }
 
-      response = post rest_url("module_type/delete_assembly_template"), post_body
+      response = post rest_url("#{module_type}/delete_assembly_template"), post_body
       return response unless response.ok?
 
-      modules_path               = OsUtil.module_clone_location(module_type)
-      module_location            = "#{modules_path}/#{module_name}" if module_name
-      assembly_template_location = "#{module_location}/assemblies/#{assembly_template_name}" if (module_location && assembly_template_name)
+      module_location = OsUtil.module_location(module_type, module_name)
+
+      if (module_location && assembly_template_name)
+        assembly_template_location = "#{module_location}/assemblies/#{assembly_template_name}"
+        base_file = "#{module_location}/assemblies/#{assembly_template_name}.dtk.assembly"
+
+        # Aldin: could not find better solution, leaving as is for now
+        assembly_file_location =
+          if File.exists?("#{base_file}.yaml")
+            "#{base_file}.yaml"
+          elsif File.exists?("#{base_file}.json")
+            "#{base_file}.json"
+          else
+            nil
+          end
+      end
 
+      FileUtils.rm("#{assembly_file_location}") if assembly_file_location
       if File.directory?(assembly_template_location)
         unless (assembly_template_location.nil? || ("#{module_location}/assemblies/" == assembly_template_location))
           FileUtils.rm_rf("#{assembly_template_location}")
@@ -600,4 +597,4 @@ module DTK::Client
     end
 
   end
-end
+end

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

@@ -2,9 +2,10 @@ dtk_require_common_commands('thor/common')
 module DTK::Client
   module PullCloneChangesMixin
     def pull_clone_changes?(module_type,module_id,version=nil,opts={})
-      module_name,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
-      Helper(:git_repo).pull_changes(module_type,module_name,opts.merge(:local_branch => branch))
+      opts_pull = opts.merge(:local_branch => branch,:namespace => module_namespace)
+      Helper(:git_repo).pull_changes(module_type,module_name,opts_pull)
     end
   end
 end

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

@@ -17,7 +17,8 @@ module DTK::Client
       )
       response = post(rest_url("#{module_type}/get_remote_module_info"),post_body)
       return response unless response.ok?
-      module_name = response.data(:module_name)
+
+      module_name,full_module_name = response.data(:module_name,:full_module_name)
       remote_params = response.data_hash_form(:remote_repo_url,:remote_repo,:remote_branch)
       remote_params.merge!(:version => version) if version
 
@@ -26,13 +27,15 @@ module DTK::Client
         import_module_component_dependencies(module_id,remote_namespace)
       end
       # check whether a local module exists to determine whether pull from local clone or try to pull from server
-      if Helper(:git_repo).local_clone_exists?(module_type,module_name,version)
+      if Helper(:git_repo).local_clone_dir_exists?(module_type,module_name,:full_module_name=>full_module_name,:version=>version)
         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
-        PullFromRemote.perform_locally(self,module_type,module_id,module_name,remote_params)
+        opts_perform_locally = remote_params.merge(:full_module_name => full_module_name)
+        PullFromRemote.perform_locally(self,module_type,module_id,module_name,opts_perform_locally)
       else
-        PullFromRemote.perform_on_server(self,module_type,module_id,module_name,remote_params)
+        # TODO: see if this works correctly
+        PullFromRemote.perform_on_server(self,module_type,module_id,full_module_name,remote_params)
       end
     end
 
@@ -52,10 +55,11 @@ module DTK::Client
       print "Resolving dependencies please wait ... "
 
       if (response.ok? && !(missing_components = response.data(:missing_modules)).empty?)
+        required_modules = response.data(:required_modules)
         puts " New dependencies found, Installing."
 
         module_opts = {:module_type => 'component-module'}
-        trigger_module_component_import(missing_components, module_opts)
+        trigger_module_component_import(missing_components, required_modules, module_opts)
 
         puts "Resuming pull from remote ..."
       else

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

@@ -9,12 +9,12 @@ module DTK::Client
       if opts[:delete_all_versions]
         dirs_to_delete += OsUtil.module_version_locations(module_type,module_name,version,opts)
       end
-      response = Response::Ok.new()  
+      response = Response::Ok.new()
       pwd = Dir.getwd()
       dirs_to_delete.each do |dir|
         if File.directory?(dir)
           if ((pwd == dir) || (pwd.include?("#{dir}/")))
-            OsUtil.print("Local directory '#{dir}' is not deleted because it is your current working directory.", :yellow) 
+            OsUtil.print("Local directory '#{dir}' is not deleted because it is your current working directory.", :yellow)
           else
             FileUtils.rm_rf(dir)
           end

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

@@ -6,13 +6,14 @@ module DTK::Client
     include CommonMixin
     ##
     #
-    # module_type: will be :component_module or :service_module 
+    # 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,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
 
-      module_location  = OsUtil.module_location(module_type,module_name,version,opts)
-      
+      full_module_name = ModuleUtil.resolve_name(module_name, module_namespace)
+      module_location  = OsUtil.module_location(module_type,full_module_name,version,opts)
+
       unless File.directory?(module_location)
         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)
@@ -22,7 +23,7 @@ module DTK::Client
       end
 
       push_opts = opts.merge(:commit_msg => commit_msg, :local_branch => branch)
-      response = Helper(:git_repo).push_changes(module_type,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)))
@@ -35,21 +36,43 @@ module DTK::Client
 
       response = post(rest_url("#{module_type}/update_model_from_clone"),post_body)
       return response unless response.ok?
-      
-      if (!response.data.empty? && response.data(:dsl_parsed_info))
-        dsl_parsed_message = ServiceImporter.error_message(module_name, response.data(:dsl_parsed_info))
-        DTK::Client::OsUtil.print(dsl_parsed_message, :red) 
-        return Response::NoOp.new() #NoOp fine because error reported by section above
+
+      ret = Response::Ok.new()
+
+      # 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)
+          ret = Response::NoOp.new()
+        end
       end
       
-      if module_type == :component_module
-        dsl_created_info = response.data(:dsl_created_info)
-        if dsl_created_info and !dsl_created_info.empty?
-          msg = "A #{dsl_created_info["path"]} file has been created for you, located at #{repo_obj.repo_dir}"
-          return Helper(:git_repo).add_file(repo_obj,dsl_created_info["path"],dsl_created_info["content"],msg)
+      # check if server pushed anything that needs to be pulled
+      dsl_updated_info = response.data(:dsl_updated_info)
+      if dsl_updated_info and !dsl_updated_info.empty?
+        if msg = dsl_updated_info["msg"] 
+          DTK::Client::OsUtil.print(msg,:yellow)
+        end
+        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?
+        end
+      end
+
+      # check if server sent any file that should be added
+      dsl_created_info = response.data(:dsl_created_info)
+      if dsl_created_info and !dsl_created_info.empty?
+        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}" 
+          response = Helper(:git_repo).add_file(path,content,msg)
+          return response unless response.ok?
         end
       end
-      Response::Ok.new()
+      ret
     end
   end
 end