dtk-client 0.11.7 → 0.11.8

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

@@ -95,26 +95,16 @@ module DTK::Client
           repo.head_commit_sha
         end
 
-        def self.clone_service_repo(args)
-          repo_url         = args.required(:repo_url)
-          branch           = args.required(:branch)
-          service_instance = args.required(:service_instance)
-          remove_existing  = args[:remove_existing]
-          repo_dir         = args[:repo_dir]
-
-          target_repo_dir = create_service_dir(service_instance, :remove_existing => remove_existing, :path => repo_dir)
+        def self.clone(repo_url, target_repo_dir,  branch)
           begin
             git_repo.clone(repo_url, target_repo_dir,  branch)
           rescue => e
-            #cleanup by deleting directory
-            
             FileUtils.rm_rf(target_repo_dir) if File.directory?(target_repo_dir)
-            # Log error details
             Logger.instance.error_pp(e.message, e.backtrace)
-            
-            # User-friendly error
+
             raise Error::Usage, "Clone to directory '#{target_repo_dir}' failed"
           end
+
           target_repo_dir
         end
 
@@ -127,15 +117,7 @@ module DTK::Client
           repo_dir        = args[:repo_dir]
 
           target_repo_dir = create_module_dir(module_type, module_name, :remove_existing => remove_existing, :path => repo_dir)
-          begin
-            git_repo.clone(repo_url, target_repo_dir,  branch)
-          rescue => e
-            FileUtils.rm_rf(target_repo_dir) if File.directory?(target_repo_dir)
-            Logger.instance.error_pp(e.message, e.backtrace)
-
-            raise Error::Usage, "Clone to directory '#{target_repo_dir}' failed"
-          end
-
+          clone(repo_url, target_repo_dir, branch)
           target_repo_dir
         end
 

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

@@ -34,9 +34,12 @@ module DTK::Client
         end
       end
 
-      def self.clone_service_repo(args)
+      def self.clone(args)
         wrap_operation(args) do |args|
-          response_data_hash(:target_repo_dir => Internal.clone_service_repo(args))
+          repo_url        = args.required(:repo_url)
+          target_repo_dir = args.required(:target_repo_dir)
+          branch          = args.required(:branch)
+          response_data_hash(:target_repo_dir => Internal.clone(repo_url, target_repo_dir, branch))
         end
       end
 
@@ -235,10 +238,6 @@ module DTK::Client
         Internal::Dtkn.repo_with_remote(info_type, repo_dir, add_remote: args[:add_remote])
       end
 
-      def self.response_data_hash(hash = {})
-        hash.inject({}) { |h, (k, v)| h.merge(k.to_s => v) }
-      end
-
     end
   end
 end

data/lib/client/operation/client_module_dir/service_instance/internal/module_info.rb

@@ -0,0 +1,67 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::ClientModuleDir
+    class ServiceInstance::Internal
+      class ModuleInfo
+        def initialize(module_info_hash)
+          @module_info_hash = module_info_hash
+        end
+        
+        def repo_url
+          index(:repo, :url)
+        end
+        
+        def branch
+          index(:branch, :name)
+        end
+        
+        def module_name
+          index(:module, :name)
+        end
+        
+        protected
+        
+        attr_reader :module_info_hash
+        
+        private
+        
+        def index(index1, index2)
+          index?(index1, index2) || raise_error_missing_key(index1, index2)
+        end     
+        
+        def index?(index1, index2)
+          (self.module_info_hash[index1.to_s] || {})[index2.to_s]
+        end
+        
+        def raise_error_missing_key(index1, index2)
+          if module_name = index?(:module, :name) 
+            if module_namespace = index?(:module, :namespace)
+              module_name = "#{module_name}:#{module_namespace}"
+            end
+          end
+          module_name ||= 'module'
+          raise Error, "Unexpected that #{module_name}[#{index1}][#{index2}] is nil"
+        end 
+
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,106 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::ClientModuleDir
+    class ServiceInstance
+      # All Internal methods do not have wrap_operation and can only be accessed by a method that wraps it
+      class Internal < self
+        require_relative('internal/module_info')
+
+        def initialize(args)
+          @base_module      = args.required(:base_module)
+          @nested_modules   = args.required(:nested_modules)
+          @service_instance = args.required(:service_instance)
+          @remove_existing  = args[:remove_existing]
+          @repo_dir         = args[:repo_dir]
+        end
+        private :initialize
+
+        def self.clone(args)
+          new(args).clone
+        end
+
+        def clone
+          @target_repo_dir = clone_base_module
+          @nested_module_base = make_nested_module_base
+          self.nested_modules.each { |nested_module| clone_nested_module(nested_module) }
+          self.target_repo_dir
+        end
+          
+        protected
+
+        attr_reader :base_module, :nested_modules, :service_instance, :remove_existing, :repo_dir
+
+        def target_repo_dir
+          @target_repo_dir || raise(Error, "Unexpected that @target_repo_dir is nil")
+        end
+
+        def nested_module_base
+          @nested_module_base || raise(Error, "Unexpected that @nested_module_base is nil")
+        end
+
+        def possible_nested_module_base_dirs
+          self.class.possible_nested_module_base_dirs
+        end
+
+        private
+
+        def clone_base_module
+          module_info = ModuleInfo.new(self.base_module)
+          target_repo_dir = self.class.create_service_dir(self.service_instance, :remove_existing => self.remove_existing, :path => self.repo_dir)
+          clone_repo(module_info, target_repo_dir)
+          target_repo_dir
+        end
+
+        def clone_nested_module(nested_module_hash)
+          module_info     = ModuleInfo.new(nested_module_hash)
+          nested_repo_dir = "#{self.nested_module_base}/#{module_info.module_name}"
+          clone_repo(module_info, nested_repo_dir)
+        end
+
+        def make_nested_module_base
+          unless nested_module_base = find_unused_path?(self.possible_nested_module_base_dirs)
+            raise Error::Usage, "The module must not have files/directories that conflict with each of #{self.possible_nested_module_base_dirs.join(', ')}"
+          end
+          FileUtils.mkdir_p(nested_module_base)
+          nested_module_base
+        end
+
+        def find_unused_path?(dirs)
+          dirs.map { |dir| "#{self.target_repo_dir}/#{dir}" }.find { |full_path| ! File.exists?(full_path) }
+        end
+
+        def clone_repo(module_info, target_repo_dir)
+          clone_args = {
+            :repo_url        => module_info.repo_url,
+            :branch          => module_info.branch,
+            :target_repo_dir => target_repo_dir
+          }
+          response = ClientModuleDir::GitRepo.clone(clone_args)
+          raise Error::Usage, response.data unless response.ok?
+        end
+
+        def self.possible_nested_module_base_dirs
+          @possible_nested_module_base_dirs ||= ::DTK::DSL::DirectoryType::ServiceInstance::NestedModule.possible_paths
+        end
+        
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,30 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::ClientModuleDir
+    # Operations for managing service instance folder content
+    class ServiceInstance < self
+      require_relative('service_instance/internal')
+      def self.clone(args)
+        wrap_operation(args) do |args|
+          response_data_hash(:target_repo_dir => Internal.clone(args))
+        end
+      end
+    end
+  end
+end

data/lib/client/operation/client_module_dir.rb

@@ -22,6 +22,7 @@ module DTK::Client
     # Operations for managing module folders
     class ClientModuleDir < self
       require_relative('client_module_dir/git_repo')
+      require_relative('client_module_dir/service_instance')
       
       NAMESPACE_SEPERATOR = ':'
       # opts can have keys
@@ -121,6 +122,10 @@ module DTK::Client
     
       private
 
+      def self.response_data_hash(hash = {})
+        hash.inject({}) { |h, (k, v)| h.merge(k.to_s => v) }
+      end
+
       def self.base_path(type)
         path =
           case type.to_sym

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

@@ -34,7 +34,7 @@ module DTK::Client
       end
 
       def clone_module
-        unless module_info = module_version_exists?(@module_ref, :type => :common_module, :remote_info => false, :rsa_pub_key => SSHUtil.rsa_pub_key_content)
+        unless module_info = module_version_exists?(@module_ref, :remote_info => false, :rsa_pub_key => SSHUtil.rsa_pub_key_content)
           raise Error::Usage, "DTK module '#{@module_ref.pretty_print}' does not exist on the DTK Server."
         end
 
@@ -100,7 +100,7 @@ module DTK::Client
         end
 
         if remote_module_info && remote_module_info.data(:service_info)
-          !module_version_exists?(@module_ref, :type => :service_module)
+          !module_version_exists?(@module_ref)
         end
       end
 

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

@@ -34,40 +34,16 @@ module DTK::Client
       end
       
       def delete_from_remote(opts = {})
-        query_string_hash = QueryStringHash.new(
-          :module_name => module_ref.module_name,
-          :namespace   => module_ref.namespace,
-          :rsa_pub_key => SSHUtil.rsa_pub_key_content,
-          :force?    => opts[:force]
-        )
-
-        unless version = module_ref.version
-          remotes = Operation::Module.list_remotes({})
-
-          selected_module = remotes.data.find{ |vr| vr['display_name'].eql?("#{module_ref.namespace}/#{module_ref.module_name}") }
-          raise Error::Usage, "Module '#{module_ref.namespace}/#{module_ref.module_name}' does not exist on repo manager!" unless selected_module
-
-          versions = selected_module['versions']
-          versions.map! { |v| v == 'base' ? 'master' : v }
-
-          if versions.size > 1
-            ret_version = Console.version_prompt(versions, "Select which module version to delete: ", { :add_all => true })
-            return unless ret_version
-            version = ret_version
-          else
-            version = versions.first
-          end
-        end
-
-        query_string_hash.merge!(:version => version)
-        query_string_hash.merge!(:versions => versions) if version.eql?('all')
-
         unless opts[:skip_prompt]
           module_ref_opts = { :namespace => module_ref.namespace }
-          module_ref_opts.merge!(:version => version) unless version.eql?('all')
-          return unless Console.prompt_yes_no("Are you sure you want to delete module '#{DTK::Common::PrettyPrintForm.module_ref(module_ref.module_name, module_ref_opts)}' from repo manager?", :add_options => true)
+          return unless Console.prompt_yes_no("Are you sure you want to delete module '#{DTK::Common::PrettyPrintForm.module_ref(module_ref.module_name, module_ref_opts)}' from dtk network?", :add_options => true)
         end
-        rest_post "#{BaseRoute}/delete_from_remote", query_string_hash
+
+        module_info = {
+          name:      module_ref.module_name,
+          namespace: module_ref.namespace
+        }
+        DtkNetworkClient::Delete.run(module_info)
 
         nil
       end

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

@@ -61,8 +61,7 @@ module DTK::Client; class Operation::Module
       end
 
       def query_if_component_module_is_installed?
-        # TODO: :type => :component_module is for legacy; once we get past having legacy can change to :common_module
-        module_version_exists?(@module_ref, :type => :component_module)
+        module_version_exists?(@module_ref)
       end
 
       private

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

@@ -34,7 +34,7 @@ module DTK::Client; class Operation::Module
             unless Install::DependentModules.resolved.include?("#{dep['namespace']}:#{dep['name']}")
               Install::DependentModules.add_to_resolved("#{dep['namespace']}:#{dep['name']}")
               dep_module_ref = Install::DependentModules.create_module_ref(dep, opts = {})
-              if dep_ref_info = module_version_exists?(dep_module_ref, :type => :component_module, :remote_info => true, :rsa_pub_key => SSHUtil.rsa_pub_key_content)
+              if dep_ref_info = module_version_exists?(dep_module_ref, :remote_info => true, :rsa_pub_key => SSHUtil.rsa_pub_key_content)
                 new_print_helper = Install::PrintHelper.new(:module_ref => dep_module_ref, :source => :remote)
                 if dep_ref_info.data(:has_remote) && !prompt_helper.update_none
                   ComponentModule.install_or_pull?(dep_module_ref, prompt_helper, new_print_helper) unless dep_module_ref.is_base_module?

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

@@ -41,7 +41,7 @@ module DTK::Client; class Operation::Module
       end
 
       def print_continuation_installing_base_module
-        print_continuation "Installing base module '#{pretty_print_module}' from #{source_term}", :color => :yellow
+        print_continuation "Installing module '#{pretty_print_module}' from #{source_term}", :color => :yellow
       end
 
       def print_continuation_pulling_base_module

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

@@ -25,12 +25,12 @@ module DTK::Client
       require_relative('install/dependent_modules')
       require_relative('install/common_module')
 
-      def initialize(file_obj, module_ref, has_remote_repo)
+      def initialize(file_obj, module_ref, has_remote_repo, install_from)
         @file_obj         = file_obj
         @base_module_ref  = module_ref
         @parsed_module    = file_obj.parse_content(:common_module_summary)
         @has_remote_repo  = has_remote_repo
-        @print_helper     = PrintHelper.new(:module_ref => @base_module_ref, :source => has_remote_repo ? :remote : :local)
+        @print_helper     = PrintHelper.new(:module_ref => @base_module_ref, :source => install_from || :local) # ? :remote : :local)
       end
       private :initialize
 
@@ -41,7 +41,8 @@ module DTK::Client
           has_directory_param    = args[:has_directory_param]
           has_remote_repo        = args[:has_remote_repo]
           update_deps            = args[:update_deps]
-          
+          install_from           = args[:install_from]
+
           case update_deps
           when "prompt"
             update_deps          = nil
@@ -55,7 +56,7 @@ module DTK::Client
             file_obj = args.required(:base_dsl_file_obj).raise_error_if_no_content
           end
 
-          new(file_obj, module_ref, has_remote_repo).install(:update_deps => update_deps, :no_update_deps => no_update_deps)
+          new(file_obj, module_ref, has_remote_repo, install_from).install(:update_deps => update_deps, :no_update_deps => no_update_deps)
         end
       end
 
@@ -67,25 +68,30 @@ module DTK::Client
           raise Error::Usage, "No base module reference #{dsl_path_ref}"
         end
 
-        if module_version_exists?(@base_module_ref, { :type => :common_module })
+        if module_version_exists?(@base_module_ref)
           raise Error::Usage, "Module '#{@base_module_ref.print_form}' exists already"
         end
 
-        unless dependent_modules.empty?
-          begin
-            if @has_remote_repo
-              DependentModules.install(@base_module_ref, dependent_modules, opts)
-            else
-              DependentModules.install_with_local(@base_module_ref, dependent_modules, opts)
-            end
-          rescue TerminateInstall
-            @print_helper.print_terminated_installation
-            return nil
-          end
-        end
+        # unless dependent_modules.empty?
+        #   begin
+        #     if @has_remote_repo
+        #       DependentModules.install(@base_module_ref, dependent_modules, opts)
+        #     else
+        #       DependentModules.install_with_local(@base_module_ref, dependent_modules, opts)
+        #     end
+        #   rescue TerminateInstall
+        #     @print_helper.print_terminated_installation
+        #     return nil
+        #   end
+        # end
 
         @print_helper.print_continuation_installing_base_module
-        CommonModule.install(@base_module_ref, @file_obj, :has_remote_repo => @has_remote_repo)
+
+        base_path = @base_module_ref.client_dir_path || @file_obj.parent_dir?
+        self.class.handle_error base_path do
+          CommonModule.install(@base_module_ref, @file_obj, :has_remote_repo => @has_remote_repo)
+        end
+
         @print_helper.print_done_message
         nil
       end
@@ -112,7 +118,7 @@ module DTK::Client
           ModuleRef.new(:namespace => dep_namespace, :module_name => dep_module_name, :version => dep_version, :is_base_module => is_base_module)
         end
         unless base_component_module_found
-          if module_version_exists?(@base_module_ref, :type => :component_module)
+          if module_version_exists?(@base_module_ref)
             ret << ModuleRef.new(:namespace => namespace, :module_name => module_name, :version => version, :is_base_module => true)
           end
         end

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

@@ -19,11 +19,12 @@ module DTK::Client
   class Operation::Module
     class InstallFromCatalog < self
       attr_reader :version, :module_ref, :target_repo_dir
-      def initialize(catalog, module_ref, directory_path, version, remote_module_info)
+      def initialize(catalog, module_ref, directory_path, version, remote_module_info, type)
+        @type               = type
         @catalog            = catalog
         @module_ref         = module_ref
         @directory_path     = directory_path
-        @target_repo_dir    = ClientModuleDir.create_module_dir_from_path(directory_path || OsUtil.current_dir)
+        @target_repo_dir    = OsUtil.current_dir unless type == :dependency #ClientModuleDir.create_module_dir_from_path(directory_path || OsUtil.current_dir)
         @version            = version # if nil wil be dynamically updated along with version attribute of @module_ref
         @remote_module_info = remote_module_info
       end
@@ -35,38 +36,23 @@ module DTK::Client
           version            = args[:version]
           directory_path     = args[:directory_path]
           remote_module_info = args[:remote_module_info]
-
+          type               = args[:type]
           # will create different classes for different catalog types when we add support for them
-          new('dtkn', module_ref, directory_path, version, remote_module_info).install_from_catalog
+          new('dtkn', module_ref, directory_path, version, remote_module_info, type).install_from_catalog
         end
       end
       
       def install_from_catalog
-        unless @remote_module_info
-          query_string_hash = QueryStringHash.new(
-            :module_name => @module_ref.module_name,
-            :namespace   => @module_ref.namespace,
-            :rsa_pub_key => SSHUtil.rsa_pub_key_content,
-            :version?    => @version
-          )
-
-          @remote_module_info = rest_get "#{BaseRoute}/remote_module_info", query_string_hash
-        end
-
-        unless @version
-          @version = @remote_module_info.required(:version)
-          @module_ref.version = @version
-        end
-
-        if module_version_exists?(@module_ref, :type => :common_module)
-          raise Error::Usage, "Module '#{@module_ref.print_form}' exists already"
-        end
-
-        create_repo_opts = { :repo_dir => @target_repo_dir, :commit_msg => "DTK client initialize" }
-        Operation::ClientModuleDir::GitRepo.create_repo_with_empty_commit(create_repo_opts)
-        LoadSource.fetch_transform_and_merge(@remote_module_info, self)
-
-        {:target_repo_dir => @target_repo_dir}
+        module_info = {
+          name:          module_ref.module_name,
+          namespace:     module_ref.namespace,
+          version:       @version,
+          explicit_path: @directory_path,
+          repo_dir:      @directory_path || @target_repo_dir
+        }
+        installed_modules = DtkNetworkClient::Install.run(module_info, type: @type)
+
+        { :installed_modules => installed_modules }
       end
 
     end

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

@@ -19,19 +19,12 @@ module DTK::Client
   class Operation::Module
     class ListRemotes < self
       def self.execute(args = Args.new)
-        wrap_operation(args) do |_args|
-
-          query_string_hash = QueryStringHash.new(
-            :detail_to_include => ['remotes', 'versions'],
-            :rsa_pub_key => SSHUtil.rsa_pub_key_content,
-            :module_namespace? => args[:module_namespace]
-          )
-          
-          rest_get("#{BaseRoute}/remote_modules", query_string_hash)
+        wrap_operation(args) do |args|
+          namespace = args[:namespace]
+          response  = DtkNetworkClient::List.run(namespace)
+          Response.new(response)
         end.set_render_as_table!
       end
     end
   end
 end
-
-

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

@@ -30,46 +30,32 @@ module DTK::Client
       def self.execute(args = Args.new)
         wrap_operation(args) do |args|
           module_ref        = args.required(:module_ref)
+          base_dsl_file_obj = args.required(:base_dsl_file_obj)
           directory_path    = args[:directory_path]
-          new('dtkn', module_ref, directory_path).publish
+          update_lock_file  = args[:update_lock_file]
+          new('dtkn', module_ref, directory_path).publish({file_obj: base_dsl_file_obj, update_lock_file: update_lock_file})
         end
       end
-      
-      def publish
-        unless module_version_exists?(module_ref, :type => :common_module)
-          raise Error::Usage, "Module #{module_ref.print_form} does not exist on server"
-        end
-
-        error_msg = "To allow publish to go through, invoke 'dtk push' to push the changes to server before invoking publish again"
-        GitRepo.modified_with_diff?(target_repo_dir, { :error_msg => error_msg })
 
-        post_body = PostBody.new(
-          :module_name => module_ref.module_name,
-          :namespace   => module_ref.namespace,
-          :version     => @version,
-          :rsa_pub_key => SSHUtil.rsa_pub_key_content
-        )
+      def publish(opts = {})
+        file_obj = opts[:file_obj]
+        parsed_module = file_obj.parse_content(:common_module_summary)
 
-        response = rest_post "#{BaseRoute}/publish_to_remote", post_body
+        module_info = {
+          name: module_ref.module_name,
+          namespace: module_ref.namespace,
+          version: @version,
+          repo_dir: @target_repo_dir
+        }
 
-        query_string_hash = QueryStringHash.new(
-          :module_name => module_ref.module_name,
-          :namespace   => module_ref.namespace,
-          :rsa_pub_key => SSHUtil.rsa_pub_key_content,
-          :version?    => @version
-        )
-        remote_module_info = rest_get "#{BaseRoute}/remote_module_info", query_string_hash
+        response = DtkNetworkClient::Publish.run(module_info, parsed_module: parsed_module, development_mode: Config[:development_mode], update_lock_file: opts[:update_lock_file])
+        OsUtil.print_info("Module '#{module_ref.pretty_print}' has been published successfully.")
 
-        unless @version
-          @version = remote_module_info.required(:version)
-          @module_ref.version = @version
+        if Config[:development_mode]
+          ret_response = { namespace_id: response['namespace_short_id'], module_version_id: response['short_id'] }
+          return ret_response
         end
 
-        # this is temporary until we implement push-dtkn from server instead of from client
-        # this part will fetch remote branches from repo manager after publish from server is finished
-        LoadSource.fetch_from_remote(remote_module_info, self)
-
-        OsUtil.print_info("'#{module_ref.pretty_print}' has been published successfully.")
         nil
       end
     end