dtk-client 0.6.7 → 0.6.8

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzJhNmY1YjNmMTQxNzRhMzI0NmZjOGYxYjczM2EwNDc3NjdiYTAxMg==
+    ZTNhNzQ0NThlZmEwYTM4MTBjY2VmYWRkMjM1MTNiOTk1NGFiNWEwYQ==
   data.tar.gz: !binary |-
-    YWZiMDcxNWJkYmEwMzI3NGIyMzMwY2FmZWQ4OTk1NWVmZmUzYWY5ZQ==
+    NTlmMzU3OTZmYTdkNjVhMWVlYThiNWE5YmVlOGE1NDQxNGJlYjhlZA==
 SHA512:
   metadata.gz: !binary |-
-    MWZlMTBiYTUwMGIwZjU5MzU0ZjNlNWY0NGVkMjcwOWZlNDk0ODU1YTM5ZWIy
-    NjY2NDQzOTBjMjFjNmQwM2U4YjQwMGFmMjU1OTVmYThiNzQ5MDZiZDg4MjY5
-    OTdkNDUwODBmMGUwZWZkMjA3Yjg4NzU1ZTI2OTdiM2NkOWZmYjg=
+    OTc0YjFhOTUzOGVmMmViMjNiMzY4MzcyZWFkMTA4M2NhY2YyZDgyMThhMThm
+    MjJlMzVlNWU4NTI3YWNjODI5YmJhMzE1YjE3ZGVhODc4NjAzZmFhZTI1OTE4
+    ZDEwMzQzMDJlM2M3MmY3YmQ4MjUwZjQ5OTY0ZGVlZGQ1OGZlNDk=
   data.tar.gz: !binary |-
-    MzUzOTVmMzhlYzg2MzcwMGVmMWZmY2M2NDg1ODhlNGQ4NWMwNWIzMTJlZTQ4
-    NTNmZWRlZWU4YmI5ZTExMGQwYmE3ZGU4ZDc3NGI3ZDgzMzNmZWQyODZhMThi
-    M2M1Yjg0YmYxNmFjNTkxNDUwNWQ5ZDhjOWZmZGQzZDY5MDAwYTQ=
+    ZjIwY2M4NWFiYmUwOWUwNDU5MGQ4ODBmNWQ1NDgwZjA3MDcyM2NjOTY3OGVi
+    YTVmOGIyMmI3YmY4OWUxNDI0OTQyODY4M2VmZmE3YTQzNzgwYzBkNDZjZDNi
+    OWUyMzkzYTYyMWY5NTIyMTE1YjkyNjRiNzM0MmUwZDg0ZWVhNzE=

data/lib/command_helpers/git_repo.rb

@@ -28,7 +28,14 @@ module DTK; module Client; class CommandHelper
 
         target_repo_dir = local_repo_dir(type,full_name,version,opts)
         if File.exists?(target_repo_dir)
-          raise ErrorUsage.new("Directory '#{target_repo_dir}' is not empty; it must be deleted or removed before retrying the command")
+          # if local copy of module exists then move that module to backups location
+          if opts[:backup_if_exist]
+            backup_dir = backup_dir(type, full_name)
+            FileUtils.mv(target_repo_dir, backup_dir)
+            puts "Backup of existing module directory moved to '#{backup_dir}'"
+          else
+            raise ErrorUsage.new("Directory '#{target_repo_dir}' is not empty; it must be deleted or removed before retrying the command", :log_error => false)
+          end
         end
 
         begin
@@ -44,7 +51,7 @@ module DTK; module Client; class CommandHelper
 
           DtkLogger.instance.error_pp(e.message, e.backtrace)
 
-          raise ErrorUsage.new(error_msg,:log_error=>false)
+          raise ErrorUsage.new(error_msg, :log_error => false)
         end
         {"module_directory" => target_repo_dir}
       end
@@ -84,6 +91,14 @@ module DTK; module Client; class CommandHelper
       end
     end
 
+    def get_remote_diffs(type, module_name, version, opts={})
+      Response.wrap_helper_actions() do
+        repo_dir = local_repo_dir(type,module_name,version)
+        repo = create(repo_dir,opts[:local_branch])
+        get_remote_diffs_aux(repo,opts)
+      end
+    end
+
     # opts can have the following keys
     #
     # :remote_repo
@@ -245,10 +260,14 @@ module DTK; module Client; class CommandHelper
         new(repo.diff_summary(local_branch,remote_reference))
       end
 
-      def self.diff_remote(repo,ref1)
-        new(repo.diff(ref1).ret_summary())
+      def self.diff_remote(repo,local_branch,remote_reference)
+        new(repo.diff_remote_summary(local_branch,remote_reference))
       end
 
+      # def self.diff_remote(repo,ref1)
+      #   new(repo.diff(ref1).ret_summary())
+      # end
+
       def any_diffs?
         changes = false
         self.each do |k,v|
@@ -353,6 +372,37 @@ module DTK; module Client; class CommandHelper
       {"diffs" => diffs, "commit_sha" => commit_sha, "repo_obj" => repo, "status" => repo.local_summary() }
     end
 
+    def get_remote_diffs_aux(repo,opts={})
+      diffs = DiffSummary.new()
+      #add any file that is untracked
+
+      # repo.stage_changes()
+      if opts[:remote_repo] and opts[:remote_repo_url]
+        repo.add_remote(opts[:remote_repo],opts[:remote_repo_url])
+      end
+
+      unless opts[:no_fetch]
+        repo.fetch(remote(opts[:remote_repo]))
+      end
+
+      local_branch      = repo.local_branch_name
+      remote_branch_ref = remote_branch_ref(local_branch, opts)
+
+      commit_shas = Hash.new
+      merge_rel   = repo.merge_relationship(:remote_branch, remote_branch_ref, :ret_commit_shas => commit_shas)
+      commit_sha  = nil
+
+      if merge_rel == :equal
+        commit_sha = commit_shas[:other_sha]
+      elsif merge_rel == :no_remote_ref
+        diffs = DiffSummary.new_version(repo)
+        commit_sha = commit_shas[:local_sha]
+      end
+
+      diffs = DiffSummary.diff_remote(repo,local_branch, remote_branch_ref)
+      { "diffs" => (diffs[:diffs]||"").to_s, "status" => repo.local_summary() }
+    end
+
     def pull_repo_changes_aux(repo,opts={})
       diffs = DiffSummary.new()
 
@@ -417,7 +467,8 @@ module DTK; module Client; class CommandHelper
       "#{remote(opts[:remote_repo])}/#{opts[:remote_branch]||opts[:local_branch]||local_branch}"
     end
 
-    def modules_dir(type,module_name,version=nil,opts={})
+    def modules_dir(type, module_name, version=nil, opts={})
+      type = type.to_sym
       if assembly_module = opts[:assembly_module]
         OsUtil.module_location_parts(type,module_name,version,opts)[0]
       elsif type == :component_module
@@ -435,6 +486,16 @@ module DTK; module Client; class CommandHelper
       OsUtil.module_location(type,full_module_name,version,opts)
     end
 
+    def backup_dir(type, full_module_name, opts={})
+      namespace, name = full_module_name.split(':', 2)
+      module_type     = type.split('_').first
+      backups_dir     = OsUtil.backups_location()
+
+      # create backups dir if deleted for some reason
+      FileUtils::mkdir_p(backups_dir) unless File.directory?(backups_dir)
+      "#{backups_dir}/#{module_type}-#{namespace}-#{name}-#{Time.now.to_i}"
+    end
+
     def adapter_class()
       Common::GritAdapter::FileAccess
     end

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

@@ -8,10 +8,13 @@ dtk_require_common_commands('thor/task_status')
 dtk_require_common_commands('thor/set_required_params')
 dtk_require_common_commands('thor/edit')
 dtk_require_common_commands('thor/purge_clone')
+dtk_require_common_commands('thor/list_diffs')
 LOG_SLEEP_TIME_W   = DTK::Configuration.get(:tail_log_frequency)
 
 module DTK::Client
   module AssemblyWorkspaceMixin
+    include ListDiffsMixin
+
     REQ_ASSEMBLY_OR_WS_ID = [:service_id!, :workspace_id!]
 
     def get_name(assembly_or_workspace_id)
@@ -139,14 +142,9 @@ module DTK::Client
 
     def edit_module_aux(context_params)
       assembly_or_workspace_id, component_module_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1!],method_argument_names)
-      post_body = {
-        :assembly_id => assembly_or_workspace_id,
-        :module_name => component_module_name,
-        :module_type => 'component_module'
-      }
-      response = post rest_url("assembly/prepare_for_edit_module"), post_body
-      return response unless response.ok?
 
+      response = prepare_for_edit_module(assembly_or_workspace_id, component_module_name)
+      return response unless response.ok?
 
       assembly_name,component_module_id,version,repo_url,branch,commit_sha,full_module_name = response.data(:assembly_name,:module_id,:version,:repo_url,:workspace_branch,:branch_head_sha,:full_module_name)
       component_module_name = full_module_name if full_module_name
@@ -170,6 +168,24 @@ module DTK::Client
       edit_aux(:component_module,component_module_id,component_module_name,version,edit_opts)
     end
 
+    def list_remote_module_diffs(context_params)
+      assembly_or_workspace_id, component_module_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1!],method_argument_names)
+      response = prepare_for_edit_module(assembly_or_workspace_id, component_module_name)
+      return response unless response.ok?
+
+      assembly_name,component_module_id,workspace_branch,commit_sha,module_branch_idh,repo_id = response.data(:assembly_name,:module_id,:workspace_branch,:branch_head_sha,:module_branch_idh,:repo_id)
+      list_component_module_diffs(component_module_id, assembly_name, workspace_branch, commit_sha, module_branch_idh['guid'], repo_id)
+    end
+
+    def prepare_for_edit_module(assembly_or_workspace_id, component_module_name)
+      post_body = {
+        :assembly_id => assembly_or_workspace_id,
+        :module_name => component_module_name,
+        :module_type => 'component_module'
+      }
+      response = post rest_url("assembly/prepare_for_edit_module"), post_body
+    end
+
     def edit_workflow_aux(context_params)
       assembly_or_workspace_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID],method_argument_names)
       post_body = {

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

@@ -9,7 +9,7 @@ module DTK::Client
     #                   This will change behaviour of method
     # module_type: will be :component_module or :service_module
 
-    def clone_aux(module_type, module_id,version,internal_trigger,omit_output=false,opts={})
+    def clone_aux(module_type, module_id,version,internal_trigger=false,omit_output=false,opts={})
       module_name,module_namespace,repo_url,branch,not_ok_response = workspace_branch_info(module_type,module_id,version,opts)
       full_module_name = ModuleUtil.resolve_name(module_name, module_namespace)
 
@@ -19,8 +19,10 @@ module DTK::Client
 
       if response.ok?
         puts "Module '#{full_module_name}' has been successfully cloned!" unless omit_output
+        # when puppet forge import, print successfully imported instead of cloned
+        DTK::Client::OsUtil.print("Module '#{full_module_name}' has been successfully imported!", :yellow) if omit_output && opts[:print_imported]
         unless internal_trigger
-          if Console.confirmation_prompt("Would you like to edit cloned module now?")
+          if Console.confirmation_prompt("Would you like to edit module now?")
             context_params_for_module = create_context_for_module(full_module_name, module_type)
             return edit(context_params_for_module)
             # if module_type.to_s.eql?("service_module")

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

@@ -13,14 +13,14 @@ module DTK::Client
 
     ##
     #
-    # module_type: will be one of 
+    # module_type: will be one of
     # :component_module
-    # :service_module 
+    # :service_module
     def edit_aux(module_type,module_id,module_name,version,opts={})
       module_location  = OsUtil.module_location(module_type,module_name,version,opts)
 
       pull_if_needed = opts[:pull_if_needed]
-      # check if there is repository cloned 
+      # check if there is repository cloned
       unless File.directory?(module_location)
         if opts[:automatically_clone] or Console.confirmation_prompt("Edit not possible, module '#{module_name}#{version && "-#{version}"}' has not been cloned. Would you like to clone module now"+'?')
           internal_trigger = true
@@ -43,7 +43,7 @@ module DTK::Client
       grit_adapter = Helper(:git_repo).create(module_location)
       if edit_info = opts[:edit_file]
         #TODO: cleanup so dont need :base_file_name
-        file_to_edit = 
+        file_to_edit =
           if edit_info.kind_of?(String)
             edit_info
           else #edit_info.kind_of?(Hash) and has key :base_file_name
@@ -76,7 +76,7 @@ module DTK::Client
 
       # if there is no auto commit ask for confirmation
       unless auto_commit
-        confirm_msg = 
+        confirm_msg =
           if file_to_edit
             "Would you like to commit changes to the file?"
           else
@@ -85,7 +85,7 @@ module DTK::Client
         confirmed_ok = Console.confirmation_prompt(confirm_msg)
       end
       if (auto_commit || confirmed_ok)
-        if auto_commit 
+        if auto_commit
           puts "[NOTICE] You are using auto-commit option, all changes you have made will be commited."
         end
         commit_msg = user_input("Commit message")
@@ -95,13 +95,14 @@ module DTK::Client
 
         internal_trigger=true
         reparse_aux(module_location)
+        opts.merge!(:force_parse => true, :update_from_includes => true, :print_dependencies => true)
         response = push_clone_changes_aux(module_type,module_id,version,commit_msg,internal_trigger,opts)
-        
+
         # if error return
         return response unless response.ok?
       end
 
-      #TODO: temporary took out; wil put back in        
+      #TODO: temporary took out; wil put back in
       #puts "DTK SHELL TIP: Adding the client configuration parameter <config param name>=true will have the client automatically commit each time you exit edit mode" unless auto_commit
       Response::Ok.new()
     end
@@ -139,7 +140,7 @@ module DTK::Client
         #processed_val can be false so explicitly checking against nil
         unless processed_val.nil?
           ret.merge!(k => processed_val)
-        end 
+        end
       end
       ret
     end
@@ -148,7 +149,7 @@ module DTK::Client
       ret = Array.new
       array.each do |a|
         # explicit nil not removed
-        if a.nil? 
+        if a.nil?
           ret << Response::Term.nil()
         else
           processed_val = post_process(a)
@@ -167,7 +168,7 @@ end
 =begin
     # TODO: probably deprecate
     def attribute_header()
-      header_string = 
+      header_string =
       "#############################\n####  REQUIRED ATTRIBUTES\n#############################\n#\n"
     end
     # TODO: probably deprecate
@@ -179,15 +180,15 @@ end
         first_iteration_keys, first_iteration_values = [], []
         second_iteration_keys, second_iteration_values = [], []
         required_attributes = []
-        
+
         attribute_pairs = YAML.load(attributes)
-        
+
         attribute_pairs.each do |k,v|
           first_iteration_keys << k
 
           #prepare required attributes for editor display
           if v.eql?("*REQUIRED*")
-            required_attributes << k 
+            required_attributes << k
             attribute_pairs[k] = nil
             v = nil
           end
@@ -225,7 +226,7 @@ end
           edited_keys = second_iteration_keys.select{|k| !first_iteration_keys.include?(k)}
           raise DtkValidationError, "You have changed key(s) '#{edited_keys}'. We do not support key editing yet!"
         end
-        
+
         raise DtkValidationError, "No attribute changes have been made." if ((first_iteration_keys == second_iteration_keys) && (first_iteration_values == second_iteration_values))
         edited
       else

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

@@ -26,35 +26,61 @@ module DTK::Client
       }
       version = response.data(:version)
 
-      response = Helper(:git_repo).get_diffs(module_type,module_name,version,opts)
+      # response = Helper(:git_repo).get_diffs(module_type,module_name,version,opts)
+      response = Helper(:git_repo).get_remote_diffs(module_type,module_name,version,opts)
       return response unless response.ok?
 
-      added, deleted, modified = print_diffs(response.data(remote ? :diffs : :status), remote)
+      added, deleted, modified = print_diffs(response.data(:status), remote)
+      diffs = response.data(:diffs)
 
-      raise DTK::Client::DtkValidationError, "There is no changes in current workspace!" if(added.empty? && deleted.empty? && modified.empty?)
+      raise DTK::Client::DtkValidationError, "There are no changes in current workspace!" if(added.empty? && deleted.empty? && modified.empty? && diffs.empty?)
+      puts "#{diffs}" unless (diffs||"").empty?
 
       unless added.empty?
-        puts "ADDED:"
+        puts "\nNew file(s):"
         added.each do |a|
           puts "\t #{a.inspect}"
         end
       end
 
       unless deleted.empty?
-        puts "DELETED:"
+        puts "\nDeleted file(s):"
         deleted.each do |d|
           puts "\t #{d.inspect}"
         end
       end
-
-      unless modified.empty?
-        puts "MODIFIED:"
-        modified.each do |m|
-          puts "\t #{m.inspect}"
-        end
-      end
   	end
 
+    def list_remote_diffs_aux(module_type, module_id)
+      id_field = "#{module_type}_id"
+
+      post_body = {
+        id_field => module_id
+      }
+
+      response = post(rest_url("#{module_type}/list_remote_diffs"),post_body)
+      return response unless response.ok?
+
+      raise DTK::Client::DtkValidationError, "There are no diffs between module on server and remote repo!" if response.data.empty?
+      response
+    end
+
+    def list_component_module_diffs(module_id, assembly_name, workspace_branch, commit_sha, module_branch_id, repo_id)
+      post_body = {
+        :module_id => module_id,
+        :assembly_name => assembly_name,
+        :workspace_branch => workspace_branch,
+        :module_branch_id => module_branch_id,
+        :repo_id => repo_id
+      }
+
+      response = post(rest_url("assembly/list_component_module_diffs"),post_body)
+      return response unless response.ok?
+
+      raise DTK::Client::DtkValidationError, "There are no diffs between module in service instance and base module!" if response.data.empty?
+      response
+    end
+
     def print_diffs(response, remote)
       added    = []
       deleted  = []

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

@@ -0,0 +1,249 @@
+dtk_require_from_base("util/os_util")
+
+# For Aldin: dont thing these are needed although this may be stylistic, which is fine; just putting here to make where the include
+#  include ReparseMixin 
+# ..
+# are comming from
+dtk_require_common_commands('thor/push_clone_changes')
+dtk_require_common_commands('thor/reparse')
+dtk_require_common_commands('thor/common')
+
+dtk_require_from_base('commands')
+dtk_require_from_base("command_helper")
+
+module DTK::Client
+  class CommonModule
+    class Import < self
+      include CommandBase
+      include CommandHelperMixin
+      include PushCloneChangesMixin
+      include ReparseMixin
+
+      # For Rich: this is used for import-git
+      def from_git()
+        git_repo_url, module_name    = retrieve_arguments([:option_1!, :option_2!])
+        namespace, local_module_name = get_namespace_and_name(module_name, ModuleUtil::NAMESPACE_SEPERATOR)
+        
+        module_type  = @command.get_module_type(@context_params)
+        thor_options = { :git_import => true}
+        
+        unless namespace
+          namespace_response = post rest_url("namespace/default_namespace_name")
+          return namespace_response unless namespace_response.ok?
+
+          namespace = namespace_response.data
+          thor_options[:default_namespace] = namespace
+        end
+
+        opts = {
+          :namespace => namespace,
+          :branch    => @options['branch']
+        }
+        response = Helper(:git_repo).create_clone_from_optional_branch(module_type.to_sym, local_module_name, git_repo_url, opts)
+        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(thor_options)
+        create_response = from_git_or_file()
+
+        if create_response.ok?
+          module_name, module_namespace, repo_url, branch, not_ok_response = workspace_branch_info(module_type, create_response.data['module_id'], create_response.data['version'])
+          create_response = not_ok_response if not_ok_response
+        end
+
+        unless create_response.ok?
+          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
+
+          @command.delete_module_sub_aux(@context_params, local_module_name, :force_delete => true, :no_error_msg => true, :purge => true)
+          return create_response
+        end
+
+        opts_pull = {
+          :local_branch => branch,
+          :namespace => module_namespace
+        }
+        pull_response = Helper(:git_repo).pull_changes(module_type, module_name, opts_pull)
+        return pull_response unless pull_response.ok?
+
+        if external_dependencies = create_response.data(:external_dependencies)
+          print_external_dependencies(external_dependencies, 'in the git repo')
+        end
+
+        Response::Ok.new()
+      end
+
+      # For Rich: this is for import
+      def from_file()
+        module_type = @command.get_module_type(@context_params)
+        module_name = retrieve_arguments([:option_1!])
+        namespace, local_module_name = get_namespace_and_name(module_name, ModuleUtil::NAMESPACE_SEPERATOR)
+        opts = {}
+
+        response = from_git_or_file()
+        return response unless response.ok?
+
+        repo_obj         = response.data['repo_obj']
+        module_final_dir = repo_obj.repo_dir
+        old_dir          = response.data['old_dir']
+        new_module_name  = response.data['new_module_name']
+
+        module_name, module_namespace, repo_url, branch, not_ok_response = workspace_branch_info(module_type, response.data['module_id'], response.data['version'])
+        return not_ok_response if not_ok_response
+
+        opts_pull = {
+          :local_branch => branch,
+          :namespace => module_namespace
+        }
+
+        dsl_updated_info      = response.data(:dsl_updated_info)
+        dsl_created_info      = response.data(:dsl_created_info)
+        external_dependencies = response.data(:external_dependencies)
+
+        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
+
+        # 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, response.data['module_id'])
+          response = push_module_aux(@context_params, true, opts)
+
+          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
+
+        # remove source directory if no errors while importing
+        if old_dir and (old_dir != module_final_dir)
+          FileUtils.rm_rf(old_dir) unless namespace
+        end
+
+        if external_dependencies
+          print_external_dependencies(external_dependencies, 'dtk.model.yaml includes')
+        end
+
+        # if user do import from default directory (e.g. import ntp - without namespace) print message
+        DTK::Client::OsUtil.print("Module '#{new_module_name}' has been created and module directory moved to #{module_final_dir}",:yellow) unless namespace
+
+        Response::Ok.new()
+      end
+
+      # For Rich: common code for import-git and import
+      def from_git_or_file()
+        default_ns = @context_params.get_forwarded_options()[:default_namespace]
+        git_import = @context_params.get_forwarded_options()[:git_import]
+
+        name_option = git_import ? :option_2! : :option_1!
+        module_name = @context_params.retrieve_arguments([name_option])
+        module_type = @command.get_module_type(@context_params)
+        version     = @options["version"]
+        create_response = {}
+
+        # 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?
+
+        #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
+        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)
+        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]
+
+        post_body = {
+          :repo_id    => repo_id,
+          :commit_sha => commit_sha,
+          :commit_dsl => true,
+          :scaffold_if_no_dsl => true,
+          "#{module_type}_id".to_sym => module_id
+        }
+        post_body.merge!(:git_import => true) if git_import
+        response = post(rest_url("#{module_type}/update_from_initial_create"), post_body)
+
+        unless response.ok?
+          response.set_data_hash({ :full_module_name => new_module_name })
+          # 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 && git_import)
+          end
+          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)
+        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?
+
+        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
+
+        # For Rich: did not have time today, but should find better way to pass these arguments to from_git and from_file methods
+        # For Aldin: are all these values needed in teh calling fns. ANyways anotehr way to do it is to just set instance vars so from here
+        # @module_id = module_id
+        # then calling fn coudl just use @module_id
+        response.add_data_value!(:module_id, module_id)
+        response.add_data_value!(:version, version)
+        response.add_data_value!(:repo_obj, repo_obj)
+        response.add_data_value!(:old_dir, old_dir)
+        response.add_data_value!(:new_module_name, new_module_name)
+
+        response
+      end
+
+      private
+      # ... the methods that represent the basic steps of from_git and from_git_or_file
+    end
+  end
+end