dtk-client 0.7.7 → 0.7.8

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    M2QzNTFhNjlhMWNlN2YwMmM5NGMwYzY5YTViMjQ4Y2ZkYmIwNmZjOA==
+    Y2NjNGJhMTdjNzA2ZTI2ZGIzNGU5NGQwOTE2NzY4YTgzNmJlY2Y3MA==
   data.tar.gz: !binary |-
-    ZWIyZTI1NjYzYTY3MTU3NjU2MTZhY2I5YTU1N2I3NmI4OTE5OWI4ZA==
+    Y2JiNzVhYWE5YzFlY2RjNzVkOWE3ZmI0MjM3YWFhZGU3OTgxOGY1OQ==
 SHA512:
   metadata.gz: !binary |-
-    ODRlMzA2ZmQxMWE3NjQxMjEwN2U5YzNjOTlhYTYxNzhhMzI3MzFlZDFhOWYz
-    NDg1ZDRjMzNlYWMwZDY0YWYyMGU5ZjBlN2Y0NjFlYWY1Y2JkYmM0M2JhZGVi
-    Y2E0MzlkM2VkYzMwOGVlMjM4YWY3NTYxZDdhOTVhZDE3MDllNzI=
+    YmQxMGI5OWEzNDAyY2U3ZGY2MDBkODFmODZiZTAzNDljZmIwN2VjMGQ5MWMw
+    OTBjZGJmZThhMWMxZjI5MzNlZWM1MDMwNjQzNzNmMzI2YjY3NWZjNzNjMmEx
+    OGI1MWY0NDI5NWNhZjY4MTZjMWQzODY0NmVkNDE5ZjQ2NDM3ZWQ=
   data.tar.gz: !binary |-
-    M2E5YzEwMTFiMDI5ODdhYjQ0MTllNDg2YmJmMDM0MmMxM2JlYmI1NjA2MTc0
-    ZDRkN2M5ZGQzNzNlYzA2MjFlYTJiNGE3M2VkNGE0YmVjMGFhMDVjNTM5Y2Iw
-    MTYzNzcxNjdhOGNhYmVlZTAyYzRmYTViMmI2YmUwM2FiNDdlMDI=
+    MGIxMTA5YWRmZGY2YjVmNmVmOTRmNWNjODc0NjAzZmNlMGQwOTQ2ZDZiMDQ1
+    ZjRmZjY2NWMwOWYyODZlYWZlZmFlZTBhNzFmMGEwNWEzZmJkNWFjY2NlZTRl
+    MDlkYzk1ZjhjMDg5NThlOWIyNDhiMDVlMDZhZGJmODVkMDE1YTI=

data/dtk-client.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'thor','~> 0.15.4'
   gem.add_dependency 'erubis','~> 2.7.0'
   gem.add_dependency 'dtk-common-core','0.7.3'
-  gem.add_dependency 'git','1.2.8'
+  gem.add_dependency 'git','1.2.9'
   gem.add_dependency 'colorize','~> 0.5.8'
   gem.add_dependency 'highline', '1.6.16'
   gem.add_dependency 'awesome_print', '1.1.0'

data/lib/command_helpers/git_repo.rb

@@ -225,6 +225,42 @@ module DTK; module Client; class CommandHelper
       end
     end
 
+    def create_new_version(type, src_branch, module_name, src_namespace, version, repo_url, opts = {})
+      full_name_src  = ModuleUtil.join_name(module_name, src_namespace)
+      full_name_dest = "#{full_name_src}-#{version}"
+
+      local_src_dir  = local_repo_dir(type, full_name_src)
+      local_dest_dir = local_repo_dir(type, full_name_dest)
+      branch         = "#{src_branch}-v#{version}"
+      exist_already  = false
+
+      if File.directory?(local_src_dir) && !(Dir["#{local_src_dir}/*"].empty?)
+        if File.directory?(local_dest_dir) && !(Dir["#{local_dest_dir}/*"].empty?)
+          # raise ErrorUsage.new("Directory (#{local_dest_dir}) already exist with content.",:log_error=>false)
+          exist_already = true
+        else
+          FileUtils.cp_r(local_src_dir, local_dest_dir)
+        end
+      else
+        raise ErrorUsage.new("The content for module (#{full_name_src}) should be put in directory (#{local_src_dir})",:log_error=>false)
+      end
+
+      unless exist_already
+        Response.wrap_helper_actions() do
+          repo_dir = local_dest_dir
+          remote_branch = local_branch = branch
+          repo = create(repo_dir, branch, :no_initial_commit => true)
+          repo.add_remote(remote(branch), repo_url)
+          repo.checkout(branch, { :new_branch => true })
+          repo.push_with_remote(remote(), remote_branch)
+          repo.delete_branch(src_branch)
+          repo.fetch()
+        end
+      end
+
+      {'module_directory' => local_dest_dir, 'version' => version, 'branch' => branch, 'exist_already' => exist_already}
+    end
+
     def rename_and_initialize_clone_and_push(type, module_name, new_module_name, branch, repo_url, local_repo_dir, version = nil)
       # check to see if the new dir has proper naming e.g. (~/dtk/component_modules/dtk::java)
       unless local_repo_dir.match(/\/#{new_module_name.gsub(ModuleUtil::NAMESPACE_SEPERATOR,'/')}$/)

data/lib/command_helpers/service_importer.rb

@@ -24,13 +24,32 @@ module DTK::Client
     #
     def trigger_module_auto_pull(required_modules, opts = {})
       return if required_modules.empty?
+      hide_output = opts[:hide_output]
+
+      # options[:force] means this command is triggered from trigger_module_auto_import method bellow
+      unless opts[:force]
+        update_none = RemoteDependencyUtil.check_for_frozen_modules(required_modules)
+
+        if update_none
+          print "All dependent modules are frozen and will not be updated!\n" unless hide_output
+          print "Resuming pull ... " unless hide_output
+          return Response::Ok.new()
+        end
+      end
 
       if opts[:force] || Console.confirmation_prompt("Do you want to update in addition to this module its dependent modules from the catalog?")
         required_modules.each do |r_module|
           module_name = full_module_name(r_module)
           module_type = r_module['type']
+          version     = r_module['version']
+          full_name   = (version && !version.eql?('master')) ? "#{module_name}(#{version})" : module_name
 
-          print "Pulling #{module_type.gsub('_',' ')} content for '#{module_name}' ... "
+          if r_module['frozen']
+            print "Not allowed to update frozen #{module_type.gsub('_', ' ')} '#{module_name}' version '#{version}' \n" unless hide_output
+            next
+          end
+
+          print "Pulling #{module_type.gsub('_',' ')} content for '#{full_name}' ... " unless hide_output
 
           new_context_params = DTK::Shell::ContextParams.new
           new_context_params.add_context_to_params(module_type, module_type)
@@ -38,6 +57,7 @@ module DTK::Client
 
           forwarded_opts = { :skip_recursive_pull => true, :ignore_dependency_merge_conflict => true }
           forwarded_opts.merge!(:do_not_raise => true) if opts[:do_not_raise]
+          forwarded_opts.merge!(:version => version) if version && !version.eql?('master')
           new_context_params.forward_options(forwarded_opts)
 
           response = ContextRouter.routeTask(module_type, "pull_dtkn", new_context_params, @conn)
@@ -59,49 +79,58 @@ module DTK::Client
     # Method will trigger import for each missing module component
     #
     def trigger_module_auto_import(modules_to_import, required_modules, opts = {})
-      puts 'Auto-installing missing module(s)'
+      hide_output = opts[:hide_output]
+
+      puts 'Auto-installing missing module(s)' unless hide_output
       update_all  = false
-      update_none = false
+      update_none = RemoteDependencyUtil.check_for_frozen_modules(required_modules)
 
       # Print out or update installed modules from catalog
       required_modules.each do |r_module|
-        module_name = full_module_name(r_module)
-        module_type = r_module['type']
+        module_name         = full_module_name(r_module)
+        module_type         = r_module['type']
+        version             = r_module['version']
+        full_name           = (version && !version.eql?('master')) ? "#{module_name}(#{version})" : module_name
 
-        print "Using #{module_type.gsub('_', ' ')} '#{module_name}'\n"
+        print "Using #{module_type.gsub('_', ' ')} '#{full_name}'\n" unless hide_output
         next if update_none || opts[:update_none]
 
+        pull_opts = {:force => true, :do_not_raise => true}
+        pull_opts.merge!(:hide_output => hide_output) if hide_output
+
         if update_all
-          trigger_module_auto_pull([r_module], :force => true, :do_not_raise => true)
+          trigger_module_auto_pull([r_module], pull_opts)
         else
           options = required_modules.size > 1 ? %w(all none) : []
-          update  = Console.confirmation_prompt_additional_options("Do you want to update dependent #{module_type.gsub('_', ' ')} '#{module_name}' from the catalog?", options)
+          update  = Console.confirmation_prompt_additional_options("Do you want to update dependent #{module_type.gsub('_', ' ')} '#{full_name}' from the catalog?", options) unless hide_output
           next unless update
 
           if update.to_s.eql?('all')
             update_all = true
-            trigger_module_auto_pull([r_module], :force => true, :do_not_raise => true)
+            trigger_module_auto_pull([r_module], pull_opts)
           elsif update.to_s.eql?('none')
             update_none = true
           else
-            trigger_module_auto_pull([r_module], :force => true, :do_not_raise => true)
+            trigger_module_auto_pull([r_module], pull_opts)
           end
         end
       end
 
       # Trigger import/install for missing modules
-      modules_to_import.each do |m_module|
+      modules_to_import.uniq.each do |m_module|
         module_name = full_module_name(m_module)
         module_type = m_module['type']
+        version     = m_module['version']
+        full_name   = (version && !version.eql?('master')) ? "#{module_name}(#{version})" : module_name
 
         # we check if there is module_url if so we install from git
         module_url  = m_module['module_url']
 
         # descriptive message
         importing  = module_url ? "Importing" : "Installing"
-        import_msg = "#{importing} #{module_type.gsub('_', ' ')} '#{module_name}'"
+        import_msg = "#{importing} #{module_type.gsub('_', ' ')} '#{full_name}'"
         import_msg += " from git source #{module_url}" if module_url
-        print "#{import_msg} ... "
+        print "#{import_msg} ... " unless hide_output
 
         if module_url
           # import from Git source
@@ -111,13 +140,13 @@ module DTK::Client
         else
           # import from Repo Manager
           new_context_params = ::DTK::Shell::ContextParams.new([module_name])
-          new_context_params.override_method_argument!('option_2', m_module['version'])
+          new_context_params.override_method_argument!('option_2', version) if version && !version.eql?('master')
           new_context_params.forward_options(:skip_cloning => false, :skip_auto_install => true, :module_type => module_type).merge!(opts)
           response = ContextRouter.routeTask(module_type, 'install', new_context_params, @conn)
         end
 
         ignore_component_error = (new_context_params.get_forwarded_options() || {})[:ignore_component_error] && module_type.eql?('component_module')
-        puts(response.data(:does_not_exist) ? response.data(:does_not_exist) : 'Done.')
+        puts(response.data(:does_not_exist) ? response.data(:does_not_exist) : 'Done.') unless hide_output
         raise DtkError, response.error_message if !response.ok? && !ignore_component_error
       end
 
@@ -155,7 +184,7 @@ module DTK::Client
             formated_name = m['formated_name']
             # print "Cloning component module '#{formated_name}' from server ... "
             thor_options = {}
-            thor_options["version"] = m['version']
+            thor_options["version"] = m['version'] unless m['version'].eql?('base')
             thor_options["skip_edit"] = true
             thor_options["omit_output"] = true
             thor_options.merge!(:module_type => 'component-module')
@@ -189,7 +218,7 @@ module DTK::Client
     #
     # Returns: String
     def add_version?(display_name, version)
-      version = nil if 'CURRENT'.eql?(version)
+      version = nil if 'CURRENT'.eql?(version) || 'base'.eql?(version)
       (version ? "#{display_name}-#{version.strip}" : "#{display_name}")
     end
 

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

@@ -20,6 +20,11 @@ module DTK
         nil
       end
 
+      def print_simple_results(action_results_id, number_of_retries=8)
+        response = action_results(action_results_id, number_of_retries)
+        pp response
+      end
+
       def action_results(action_results_id, number_of_retries=8)
         action_body = {
           :action_results_id => action_results_id,
@@ -46,7 +51,7 @@ module DTK
         response
 
       end
-      
+
     end
   end
 end

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

@@ -223,6 +223,7 @@ module DTK::Client
         :automatically_clone => true,
         :pull_if_needed => false,
         :service_instance_module => true,
+        :skip_if_exist_check => true,
         :assembly_module => {
           :assembly_name => assembly_name,
           :version => version
@@ -375,7 +376,8 @@ module DTK::Client
         :remote_branch => base_module_branch,
         :commit_sha    => branch_head_sha,
         :current_branch_sha => current_branch_sha,
-        :full_module_name => module_name
+        :full_module_name => module_name,
+        :skip_if_exist_check => true
       }
       opts = {:local_branch => local_branch, :namespace => namespace}
 

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

@@ -9,35 +9,52 @@ 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=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)
+    def clone_aux(module_type, module_id, version, internal_trigger = false, omit_output = false, opts = {})
+      # if version = base do not clone latest, just base
+      if version && version.eql?('base')
+        version = nil
+        opts[:use_latest] = false
+      end
 
+      module_name, module_namespace, repo_url, branch, not_ok_response, version = workspace_branch_info(module_type, module_id, version, opts)
       return not_ok_response if not_ok_response
+
+      # clone base version first if not cloned already
+      clone_base_aux(module_type, module_id, "#{module_namespace}:#{module_name}") if opts[:use_latest] && version
+
+      module_location = OsUtil.module_location(module_type, "#{module_namespace}:#{module_name}", version)
+      raise DTK::Client::DtkValidationError, "#{module_type.to_s.gsub('_',' ').capitalize} '#{module_name}#{version && "-#{version}"}' already cloned!" if File.directory?(module_location) && !opts[:skip_if_exist_check]
+
+      full_module_name = ModuleUtil.resolve_name(module_name, module_namespace)
+
       # TODO: should we use instead Helper(:git_repo).create_clone_from_optional_branch
       response = Helper(:git_repo).create_clone_with_branch(module_type,module_name,repo_url,branch,version,module_namespace,opts)
 
       if response.ok?
-        puts "Module '#{full_module_name}' has been successfully cloned!" unless omit_output
+        print_name = "Module '#{full_module_name}'"
+        print_name << " version '#{version}'" if version
+        puts "#{print_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]
+        DTK::Client::OsUtil.print("#{print_name} has been successfully imported!", :yellow) if omit_output && opts[:print_imported]
         unless internal_trigger
           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")
-            #   context_params_for_module = create_context_for_module(module_name, :"service-module")
-            # elsif module_type.to_s.eql?("component_module")
-            #   context_params_for_module = create_context_for_module(module_name, :"component-module")
-            # elsif module_type.to_s.eql?("test_module")
-            #   context_params_for_module = create_context_for_module(module_name, :"test-module")
-            # end
           end
         end
       end
+
       response
     end
 
+    # clone base module version
+    def clone_base_aux(module_type, module_id, full_module_name)
+      base_module_location = OsUtil.module_location(module_type, full_module_name, nil)
+      unless File.directory?(base_module_location)
+        clone_aux(module_type, module_id, nil, true)
+      end
+    end
+
     def create_context_for_module(full_module_name, module_type)
       context_params_for_module = DTK::Shell::ContextParams.new
       context_params_for_module.add_context_to_params(full_module_name, module_type.to_s.gsub!(/\_/,'-').to_sym, full_module_name)

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

@@ -1,26 +1,32 @@
 module DTK::Client
   module CommonMixin
    private
-    # returns module_name,module_namespace,repo_url,branch,not_ok_response( only if error)
+    # returns module_name, module_namespace, repo_url, branch, not_ok_response( only if error)
     def workspace_branch_info(module_type, module_id, version, opts={})
       # shortcut if have info about workspace branch already
       if info = opts[:workspace_branch_info]
         name_or_full_module_name = info[:module_name]
-        module_namespace,module_name = ModuleUtil.full_module_name_parts?(name_or_full_module_name)
+        module_namespace, module_name = ModuleUtil.full_module_name_parts?(name_or_full_module_name)
         module_namespace ||= info[:module_namespace]
-        ret = [module_name,module_namespace,info[:repo_url],info[:branch]]
+        ret = [module_name, module_namespace, info[:repo_url], info[:branch]]
         unless  ret.find{|r|r.nil?}
           return ret
         end
       end
 
-      post_body = get_workspace_branch_info_post_body(module_type,module_id,version,opts)
+      # if 'base' returned as version set to nil; 'base' = 'master' = nil
+      version = nil if version == 'base'
+
+      post_body = get_workspace_branch_info_post_body(module_type, module_id, version, opts)
       response = post(rest_url("#{module_type}/get_workspace_branch_info"),post_body)
       unless response.ok?
-        [nil,nil,nil,nil,response]
+        ret = [nil, nil, nil, nil, response, nil]
       else
-        response.data(:module_name,:module_namespace,:repo_url,:workspace_branch)
+        m_name, m_namespace, repo_url, w_branch, version = response.data(:module_name, :module_namespace, :repo_url, :workspace_branch, :version)
+        ret = [m_name, m_namespace, repo_url, w_branch, nil]
+        ret << version if opts[:use_latest]
       end
+      ret
     end
 
     def get_workspace_branch_info_post_body(module_type, module_id, version_explicit, opts={})
@@ -35,6 +41,9 @@ module DTK::Client
       if assembly_module
         post_body.merge!(:assembly_module => true,:assembly_name => assembly_module[:assembly_name])
       end
+      if use_latest = opts[:use_latest]
+        post_body.merge!(:use_latest => use_latest)
+      end
       post_body
     end
 

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

@@ -2,7 +2,7 @@ dtk_require('common_base')
 module DTK; module Client; module Commands::Common
   class CreateTarget < Base
     # option_list is of form [:provider!, :region, :keypair, :security_group!] indcating what is optional and what is required
-    def execute(type,option_list)
+    def execute(type, option_list)
       # we use :target_id but that will return provider_id (another name for target template ID)
       target_name = retrieve_arguments([:option_1])
       iaas_properties = iaas_properties(type,option_list)
@@ -12,12 +12,15 @@ module DTK; module Client; module Commands::Common
         :provider_id      => provider,
         :iaas_properties  => iaas_properties
       }
-      post_body.merge!(:target_name => target_name) if target_name
+
+      # cleanup for target name not being sterilazied correctly
+      post_body.merge!(:target_name => target_name.split(' ').first) if target_name
+
       post 'target/create', post_body
     end
 
    private
-    def iaas_properties(type,option_list)
+    def iaas_properties(type, option_list)
       iaas_properties = retrieve_option_hash(option_list)
       special_processing_security_groups!(iaas_properties)
       special_processing_region!(iaas_properties)
@@ -32,12 +35,12 @@ module DTK; module Client; module Commands::Common
     end
 
     def special_processing_security_groups!(iaas_properties)
-      if security_group = iaas_properties[:security_group] 
+      if security_group = iaas_properties[:security_group]
         if security_group.end_with?(',')
           raise DtkValidationError.new("Multiple security groups should be separated with ',' and without spaces between them (e.g. --security_groups gr1,gr2,gr3,...) ")
         end
         security_groups = security_group.split(',')
-        
+
         unless security_groups.empty? || security_groups.size==1
           iaas_properties.delete(:security_group)
           iaas_properties.merge!(:security_group_set => security_groups)

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

@@ -95,7 +95,9 @@ module DTK::Client
 
         internal_trigger=true
         reparse_aux(module_location)
-        opts.merge!(:force_parse => true, :update_from_includes => true, :print_dependencies => true)
+
+        # use_impl_id - if edit-component-module which has version use impl_id from assembly--<assembly_name> version of component instance
+        opts.merge!(:force_parse => true, :update_from_includes => true, :print_dependencies => true, :use_impl_id => true)
         response = push_clone_changes_aux(module_type,module_id,version,commit_msg,internal_trigger,opts)
 
         # if error return

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

@@ -101,25 +101,52 @@ module DTK::Client
       module_type = get_module_type(context_params)
 
       unless (options.force? || method_opts[:force_delete])
-        is_go = Console.confirmation_prompt("Are you sure you want to delete module '#{module_name}'"+"?")
+        msg = "Are you sure you want to delete module '#{module_name}'"
+        msg += " version '#{version}'" if version
+        is_go = Console.confirmation_prompt("#{msg}"+"?")
         return nil unless is_go
       end
 
-      post_body = {
-       "#{module_type}_id".to_sym => module_id
-      }
-      action = (version ? "delete_version" : "delete")
-      post_body[:version] = version if version
+      post_body = { "#{module_type}_id".to_sym => module_id }
+      opts = { :module_name => module_name }
+
+      unless version
+        post_body.merge!(:include_base => true)
 
-      response = post(rest_url("#{module_type}/#{action}"), post_body)
+        versions_response = post rest_url("#{module_type}/list_versions"), post_body
+        return versions_response unless versions_response.ok?
+
+        versions = versions_response.data.first['versions']
+        if versions.size > 2
+          versions << "all"
+          ret_version = Console.confirmation_prompt_multiple_choice("\nSelect version to delete:", versions)
+          return unless ret_version
+          raise DtkError, "You are not allowed to delete 'base' version while other versions exist!" if ret_version.eql?('base')
+          version = ret_version
+        end
+      end
+
+      if version
+        if version.eql?('all')
+          post_body.merge!(:delete_all_versions => true)
+          opts.merge!(:delete_all_versions => true)
+        else
+          post_body.merge!(:version => version)
+          opts.merge!(:version => version)
+        end
+      end
+
+      response = post(rest_url("#{module_type}/delete"), post_body)
       return response unless response.ok?
 
+      # if we do not provide version, server will calculate the latest version which we can use here
+      unless version
+        version = response.data(:version)
+        opts.merge!(:version => version)
+      end
+
       response =
         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)
-          end
           purge_clone_aux(module_type.to_sym, opts)
         else
           Helper(:git_repo).unlink_local_clone?(module_type.to_sym, module_name, version)
@@ -128,10 +155,14 @@ module DTK::Client
       return response unless response.ok?
 
       unless method_opts[:no_error_msg]
-        msg = "Module '#{module_name}' "
-        if version then msg << "version #{version} has been deleted"
-        else msg << "has been deleted"; end
-        OsUtil.print(msg, :yellow)
+        if version && version.eql?('all')
+          OsUtil.print("All versions of '#{module_name}' module have been deleted.", :yellow)
+        else
+          msg = "Module '#{module_name}' "
+          if version then msg << "version '#{version}' has been deleted successfully."
+          else msg << "has been deleted successfully."; end
+          OsUtil.print(msg, :yellow)
+        end
       end
 
       Response::Ok.new()
@@ -204,15 +235,27 @@ module DTK::Client
       CommonModule::Import.new(self, context_params).from_file()
     end
 
-    def install_module_aux(context_params)
+    def install_module_aux(context_params, internal_trigger = false)
       create_missing_clone_dirs()
       resolve_direct_access(::DTK::Client::Configurator.check_direct_access)
+
       remote_module_name, version = context_params.retrieve_arguments([:option_1!, :option_2], method_argument_names)
+      forwarded_version           = context_params.get_forwarded_options()['version']
+      add_version                 = false
+
+      version ||= forwarded_version || options.version
+      version = nil if version.eql?('master')
+      if version
+        check_version_format(version)
+        add_version = true
+      end
+
       # in case of auto-import via service import, we skip cloning to speed up a process
-      skip_cloning = context_params.get_forwarded_options()['skip_cloning'] if context_params.get_forwarded_options()
-      do_not_raise = context_params.get_forwarded_options()[:do_not_raise] if context_params.get_forwarded_options()
+      skip_cloning  = context_params.get_forwarded_options()['skip_cloning'] if context_params.get_forwarded_options()
+      do_not_raise  = context_params.get_forwarded_options()[:do_not_raise] if context_params.get_forwarded_options()
       skip_ainstall = context_params.get_forwarded_options() ? context_params.get_forwarded_options()[:skip_auto_install] : false
-      module_type  = get_module_type(context_params)
+      skip_base     = context_params.get_forwarded_options()['skip_base']
+      module_type   = get_module_type(context_params)
 
       # ignore_component_error = context_params.get_forwarded_options()[:ignore_component_error]||options.ignore? if context_params.get_forwarded_options()
       ignore_component_error = context_params.get_forwarded_options().empty? ? options.ignore? : context_params.get_forwarded_options()[:ignore_component_error]
@@ -220,13 +263,6 @@ module DTK::Client
 
       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
-
-        raise DtkError, message unless ignore_component_error
-      end
-
       post_body = {
         :remote_module_name => remote_module_name.sub(':', '/'),
         :local_module_name => local_module_name,
@@ -237,15 +273,42 @@ module DTK::Client
       post_body.merge!(:additional_message => additional_message) if additional_message
       post_body.merge!(:skip_auto_install => skip_ainstall) if skip_ainstall
 
+      # we need to install base module version if not installed
+      unless skip_base
+        master_response = install_base_version_aux?(context_params, post_body, module_type, version)
+        return master_response unless master_response.ok?
+
+        latest_version = master_response.data(:latest_version)
+
+        unless version
+          version = latest_version.eql?('master') ? nil : latest_version
+        end
+
+        post_body.merge!(:hard_reset_on_pull_version => true) if version
+      end
+
+      if version
+        add_version = true
+        post_body.merge!(:version => version)
+      end
+
+      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."
+        raise DtkError, message unless ignore_component_error
+      end
+
       response = post rest_url("#{module_type}/import"), post_body
 
-      # print permission warnings and then check for other warnings
-      are_there_warnings = RemoteDependencyUtil.check_permission_warnings(response)
-      are_there_warnings ||= RemoteDependencyUtil.print_dependency_warnings(response, nil, :ignore_permission_warnings => true)
+      # when silently installing base version we don't want to print anything
+      unless skip_base
+        # print permission warnings and then check for other warnings
+        are_there_warnings = RemoteDependencyUtil.check_permission_warnings(response)
+        are_there_warnings ||= RemoteDependencyUtil.print_dependency_warnings(response, nil, :ignore_permission_warnings => true)
 
-      # prompt to see if user is ready to continue with warnings/errors
-      if are_there_warnings
-        return false unless Console.confirmation_prompt('Do you still want to proceed with import' + '?')
+        # prompt to see if user is ready to continue with warnings/errors
+        if are_there_warnings
+          return false unless Console.confirmation_prompt('Do you still want to proceed with import' + '?')
+        end
       end
 
       # case when we need to import additional components
@@ -254,17 +317,19 @@ module DTK::Client
         opts = { :do_not_raise => true }
         module_opts = ignore_component_error ? opts.merge(:ignore_component_error => true) : opts.merge(:additional_message => true)
         module_opts.merge!(:update_none => true) if options.update_none?
+        module_opts.merge!(:hide_output => true) if skip_base
 
         continue = trigger_module_auto_import(missing_components, required_components, module_opts)
         return unless continue
 
-        print "Resuming DTK Network import for #{module_type} '#{remote_module_name}' ..."
+        print_remote_name = add_version ? "#{remote_module_name}(#{version})" : remote_module_name
+        print "Resuming DTK Network import for #{module_type} '#{print_remote_name}' ..." unless skip_base
         # repeat import call for service
         post_body.merge!(opts)
         response = post rest_url("#{module_type}/import"), post_body
 
         # we set skip cloning since it is already done by import
-        puts ' Done'
+        puts ' Done' unless skip_base
       end
 
       return response if !response.ok? || response.data(:does_not_exist)
@@ -284,51 +349,189 @@ module DTK::Client
       response
     end
 
+    def install_base_version_aux?(context_params, post_body, module_type, version)
+      master_response = post rest_url("#{module_type}/prepare_for_install_module"), post_body
+      return master_response unless master_response.ok?
+
+      head_installed     = master_response.data(:head_installed)
+      latest_version     = master_response.data(:latest_version)
+      remote_module_name = context_params.retrieve_arguments([:option_1!], method_argument_names)
+
+      if version
+        versions = master_response.data(:versions)
+        raise DtkError, "Module '#{remote_module_name}' version '#{version}' does not exist on repo manager!" unless versions.include?(version)
+      end
+
+      if !head_installed && !latest_version.eql?('master')
+        new_context_params = DTK::Shell::ContextParams.new
+        new_context_params.add_context_to_params(module_type, module_type)
+        new_context_params.method_arguments = [remote_module_name]
+        new_context_params.forward_options('skip_base' => true, 'version' => 'master')
+        install_module_aux(new_context_params)
+      end
+
+      master_response
+    end
+
     def delete_from_catalog_aux(context_params)
       module_type        = get_module_type(context_params)
       remote_module_name = context_params.retrieve_arguments([:option_1!], method_argument_names)
+      version            = options.version
+      rsa_pub_key        = SSHUtil.rsa_pub_key_content()
 
       # remote_module_name can be namespace:name or namespace/name
       remote_namespace, remote_module_name = get_namespace_and_name(remote_module_name, ':')
 
+      if version
+        check_version_format(version)
+      else
+        list_post_body = {
+          "#{module_type}_id".to_sym => "#{remote_namespace}:#{remote_module_name}",
+          :rsa_pub_key => rsa_pub_key,
+          :include_base => true
+        }
+        # versions_response = post rest_url("#{module_type}/list_remote_versions"), list_post_body
+        versions_response = post rest_url("#{module_type}/list_remote"), list_post_body
+        return versions_response unless versions_response.ok?
+
+        selected_module = versions_response.data.find{ |vr| vr['display_name'].eql?("#{remote_namespace}/#{remote_module_name}") }
+        raise DtkError, "Module '#{remote_namespace}/#{remote_module_name}'' does not exist on repo manager!" unless selected_module
+
+        versions = selected_module['versions']
+        if versions.size > 2
+          versions << "all"
+          ret_version = Console.confirmation_prompt_multiple_choice("\nSelect version to delete:", versions)
+          return unless ret_version
+          raise DtkError, "You are not allowed to delete 'base' version while other versions exist!" if ret_version.eql?('base')
+          version = ret_version
+        end
+      end
+
       unless options.force? || options.confirmed?
-        return unless Console.confirmation_prompt("Are you sure you want to delete remote #{module_type} '#{remote_namespace.nil? ? '' : remote_namespace + '/'}#{remote_module_name}' and all items contained in it" + '?')
+        msg = "Are you sure you want to delete remote #{module_type} '#{remote_namespace.nil? ? '' : remote_namespace + '/'}#{remote_module_name}'"
+        msg += " version '#{version}'" if version
+        msg += " and all items contained in it"
+        return unless Console.confirmation_prompt(msg + '?')
       end
 
       post_body = {
-        :rsa_pub_key             => SSHUtil.rsa_pub_key_content(),
+        :rsa_pub_key             => rsa_pub_key,
         :remote_module_name      => remote_module_name,
         :remote_module_namespace => remote_namespace,
         :force_delete            => options.force?
       }
+      post_body.merge!(:version => version) if version
+
+      response = post rest_url("#{module_type}/delete_remote"), post_body
+      return response unless response.ok?
 
-      post rest_url("#{module_type}/delete_remote"), post_body
+      full_module_name, version = response.data(:module_full_name, :version)
+      msg = "Module '#{full_module_name}' "
+      msg << "version '#{version}'" if version && !version.eql?('master')
+      msg << " has been deleted successfully."
+      OsUtil.print(msg, :yellow)
+
+      Response::Ok.new()
     end
 
     def publish_module_aux(context_params)
-      module_type  = get_module_type(context_params)
-      module_id, input_remote_name = context_params.retrieve_arguments([REQ_MODULE_ID, :option_1], method_argument_names)
+      module_type = get_module_type(context_params)
+      module_id, module_name, input_remote_name = context_params.retrieve_arguments([REQ_MODULE_ID, REQ_MODULE_NAME, :option_1!], method_argument_names)
+
+      raise DtkValidationError, "You have to provide version you want to publish!" unless options.version
+
+      skip_base         = context_params.get_forwarded_options()['skip_base']
+      forwarded_version = context_params.get_forwarded_options()['version']
+
+      version = forwarded_version||options.version
+      version = nil if version.eql?('master')
+
+      forward_namespace?(module_name, input_remote_name, context_params)
 
       post_body = {
         "#{module_type}_id".to_sym => module_id,
         :remote_component_name => input_remote_name,
-        :rsa_pub_key => SSHUtil.rsa_pub_key_content()
+        :rsa_pub_key => SSHUtil.rsa_pub_key_content(),
       }
 
+      unless skip_base
+        check_response = post rest_url("#{module_type}/check_remote_exist"), post_body
+        return check_response unless check_response.ok?
+
+        remote_exist = check_response.data(:remote_exist)
+        unless remote_exist
+          context_params.forward_options('skip_base' => true, 'version' => 'master')
+          resp = publish_module_aux(context_params)
+          return resp unless resp.ok?
+        end
+
+        context_params.forward_options('do_not_raise_if_exist' => true, 'version' => version)
+        create_response = create_new_version_aux(context_params, true)
+        return create_response unless create_response.ok?
+      end
+
+      post_body.merge!(:version => version) if version
       response = post rest_url("#{module_type}/export"), post_body
       return response unless response.ok?
 
-      full_module_name = "#{response.data['remote_repo_namespace']}/#{response.data['remote_repo_name']}"
+      unless skip_base
+        full_module_name = "#{response.data['remote_repo_namespace']}/#{response.data['remote_repo_name']}"
+        DTK::Client::RemoteDependencyUtil.print_dependency_warnings(response, "Module has been successfully published to '#{full_module_name}' version '#{version}'!")
+      end
 
-      DTK::Client::RemoteDependencyUtil.print_dependency_warnings(response, "Module has been successfully published to '#{full_module_name}'!")
       Response::Ok.new()
     end
 
+    # def publish_module_aux(context_params)
+    #   module_type  = get_module_type(context_params)
+    #   module_id, module_name, input_remote_name = context_params.retrieve_arguments([REQ_MODULE_ID, REQ_MODULE_NAME, :option_1], method_argument_names)
+
+    #   post_body = {
+    #     "#{module_type}_id".to_sym => module_id,
+    #     :remote_component_name => input_remote_name,
+    #     :rsa_pub_key => SSHUtil.rsa_pub_key_content()
+    #   }
+    #   if options.version?
+    #     post_body.merge!(:version => options.version)
+    #   else
+    #     post_body.merge!(:use_latest => true)
+    #   end
+
+    #   # check if module exist on repo manager and use it to decide if need to push or publish
+    #   check_response = post rest_url("#{module_type}/check_remote_exist"), post_body
+    #   return check_response unless check_response.ok?
+
+    #   unless options.version?
+    #     version = check_response.data(:version)
+    #     context_params.forward_options('version' => version)
+    #     post_body.merge!(:version => version)
+    #   end
+
+    #   # if remote module exist and user call 'publish' we do push-dtkn else we publish it as new module
+    #   response_data = check_response['data']
+    #   if response_data["remote_exist"]
+    #     raise DtkValidationError, "You are not allowed to update #{module_type} versions!" if response_data['frozen']
+
+    #     # if do publish namespace2/module from namespace1/module, forward namespace as option to be used in push_dtkn_module_aux
+    #     forward_namespace?(module_name, input_remote_name, context_params)
+
+    #     push_dtkn_module_aux(context_params, true)
+    #   else
+    #     response = post rest_url("#{module_type}/export"), post_body
+    #     return response unless response.ok?
+
+    #     full_module_name = "#{response.data['remote_repo_namespace']}/#{response.data['remote_repo_name']}"
+
+    #     DTK::Client::RemoteDependencyUtil.print_dependency_warnings(response, "Module has been successfully published to '#{full_module_name}'!")
+    #     Response::Ok.new()
+    #   end
+    # end
+
     def pull_dtkn_aux(context_params)
       module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID,REQ_MODULE_NAME,:option_1],method_argument_names)
 
       catalog      = 'dtkn'
-      version      = options.version
+      version      = options.version||context_params.get_forwarded_options()[:version]
       module_type  = get_module_type(context_params)
       skip_recursive_pull = context_params.get_forwarded_options()[:skip_recursive_pull]
       ignore_dependency_merge_conflict = context_params.get_forwarded_options()[:skip_recursive_pull]
@@ -391,18 +594,14 @@ module DTK::Client
       response
     end
 
-    def clone_module_aux(context_params, internal_trigger=false)
+    def clone_module_aux(context_params, internal_trigger = false)
       module_type      = get_module_type(context_params)
       thor_options     = context_params.get_forwarded_options() || options
       module_id        = context_params.retrieve_arguments([REQ_MODULE_ID], method_argument_names)
       module_name      = context_params.retrieve_arguments(["#{module_type}_name".to_sym],method_argument_names)
-      version          = thor_options["version"]
+      version          = thor_options["version"]||options.version
       internal_trigger = true if thor_options['skip_edit']
-
-      module_location = OsUtil.module_location(module_type, module_name, version)
-
-      raise DTK::Client::DtkValidationError, "#{module_type.gsub('_',' ').capitalize} '#{module_name}#{version && "-#{version}"}' already cloned!" if File.directory?(module_location)
-      clone_aux(module_type.to_sym, module_id, version, internal_trigger, thor_options['omit_output'])
+      clone_aux(module_type.to_sym, module_id, version, internal_trigger, thor_options['omit_output'], :use_latest => true)
     end
 
     def edit_module_aux(context_params)
@@ -478,7 +677,7 @@ module DTK::Client
     def push_dtkn_module_aux(context_params, internal_trigger=false)
       module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID, REQ_MODULE_NAME],method_argument_names)
       catalog     = 'dtkn'
-      version     = options["version"]
+      version     = options["version"]||context_params.get_forwarded_thor_option('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
@@ -489,7 +688,8 @@ module DTK::Client
 
       if catalog.to_s.eql?("dtkn")
         module_refs_content = RemoteDependencyUtil.module_ref_content(module_location)
-        remote_module_info  = get_remote_module_info_aux(module_type.to_sym, module_id, options["namespace"], version, module_refs_content, local_namespace)
+        options_namespace = options["namespace"]||context_params.get_forwarded_thor_option('namespace')
+        remote_module_info  = get_remote_module_info_aux(module_type.to_sym, module_id, options_namespace, version, module_refs_content, local_namespace)
         return remote_module_info unless remote_module_info.ok?
 
         unless File.directory?(module_location)
@@ -542,6 +742,29 @@ module DTK::Client
       list_remote_diffs_aux(module_type.to_sym, module_id)
     end
 
+    def list_versions_aux(context_params)
+      module_type  = get_module_type(context_params)
+      module_id    = context_params.retrieve_arguments([REQ_MODULE_ID], method_argument_names)
+      include_base = context_params.get_forwarded_options()['include_base']
+
+      post_body = { "#{module_type}_id".to_sym => module_id }
+      post_body.merge!(:include_base => include_base) if include_base
+
+      response = post rest_url("#{module_type}/list_versions"), post_body
+    end
+
+    def list_remote_versions_aux(context_params)
+      module_type  = get_module_type(context_params)
+      module_id = context_params.retrieve_arguments([REQ_MODULE_ID], method_argument_names)
+
+      post_body = {
+        "#{module_type}_id".to_sym => module_id,
+        :rsa_pub_key => SSHUtil.rsa_pub_key_content()
+      }
+
+      response = post rest_url("#{module_type}/list_remote_versions"), post_body
+    end
+
     def delete_assembly_aux(context_params)
       module_type = get_module_type(context_params)
 
@@ -638,8 +861,99 @@ module DTK::Client
       Response::Ok.new()
     end
 
+    def create_new_version_aux(context_params, internal_trigger = false)
+      module_type = get_module_type(context_params)
+      module_id, version = context_params.retrieve_arguments([REQ_MODULE_ID, :option_1!], method_argument_names)
+
+      version = (context_params.get_forwarded_options()['version'] || options.version) if internal_trigger
+
+      module_name           = context_params.retrieve_arguments(["#{module_type}_name".to_sym],method_argument_names)
+      namespace, name       = get_namespace_and_name(module_name,':')
+      do_not_raise_if_exist = context_params.get_forwarded_options()['do_not_raise_if_exist']
+
+      module_location = OsUtil.module_location(module_type, module_name, nil)
+      unless File.directory?(module_location)
+        if Console.confirmation_prompt("Module '#{module_name}' has not been cloned. Would you like to clone module now"+'?')
+          response = clone_aux(module_type.to_sym, module_id, nil, true)
+          return response unless response.ok?
+        end
+      end
+
+      opts = {:do_not_raise_if_exist => do_not_raise_if_exist} if do_not_raise_if_exist
+      m_name, m_namespace, repo_url, branch, not_ok_response = workspace_branch_info(module_type, module_id, nil)
+      resp = Helper(:git_repo).create_new_version(module_type, branch, name, namespace, version, repo_url, opts||{})
+
+      post_body = get_workspace_branch_info_post_body(module_type, module_id, version)
+      post_body.merge!(:do_not_raise_if_exist => do_not_raise_if_exist) if do_not_raise_if_exist
+      create_response = post(rest_url("#{module_type}/create_new_version"), post_body)
+
+      unless create_response.ok?
+        FileUtils.rm_rf("#{resp['module_directory']}") unless resp['exist_already']
+        return create_response
+      end
+
+      if version_exist = create_response.data(:version_exist)
+        return create_response if do_not_raise_if_exist
+      end
+
+      if error = create_response.data(:dsl_parse_error)
+        dsl_parsed_message = ServiceImporter.error_message(module_name, error)
+        DTK::Client::OsUtil.print(dsl_parsed_message, :red)
+      end
+
+      if external_dependencies = create_response.data(:external_dependencies)
+        print_dependencies(external_dependencies)
+      end
+
+      if component_module_refs = create_response.data(:component_module_refs)
+        print_using_dependencies(component_module_refs)
+      end
+
+      Response::Ok.new()
+    end
+
     def print_ambiguous(ambiguous)
     end
 
+    def forward_namespace?(module_name, input_remote_name, context_params)
+      return unless input_remote_name
+      local_namespace, local_name   = get_namespace_and_name(module_name,':')
+      remote_namespace, remote_name = get_namespace_and_name(input_remote_name,'/')
+      context_params.forward_options('namespace' => remote_namespace) unless local_namespace.eql?(remote_namespace)
+    end
+
+    def print_dependencies(dependencies)
+      ambiguous        = dependencies["ambiguous"]||[]
+      amb_sorted       = ambiguous.map { |k,v| "#{k.split('/').last} (#{v.join(', ')})" }
+      inconsistent     = dependencies["inconsistent"]||[]
+      possibly_missing = dependencies["possibly_missing"]||[]
+
+      OsUtil.print("There are inconsistent module dependencies mentioned in dtk.model.yaml: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
+      OsUtil.print("There are missing module dependencies mentioned in dtk.model.yaml: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+      OsUtil.print("There are ambiguous module dependencies mentioned in dtk.model.yaml: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) if ambiguous && !ambiguous.empty?
+    end
+
+    def print_using_dependencies(component_refs)
+      unless component_refs.empty?
+        puts 'Using component modules:'
+        names = []
+        component_refs.values.each do |cmp_ref|
+          version = cmp_ref['version_info']
+          name    = "#{cmp_ref['namespace_info']}:#{cmp_ref['module_name']}"
+          name << "(#{version})" if version
+          names << name
+        end
+        names.sort.each do |name|
+          puts "  #{name}"
+        end
+      end
+    end
+
+    def check_version_format(version)
+      unless version.match(/\A\d{1,2}\.\d{1,2}\.\d{1,2}\Z/)
+        raise DtkValidationError, "Version has an illegal value '#{version}', format needed: '##.##.##'"
+      end
+    end
+
   end
 end