dtk-client 0.5.6.1

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

@@ -0,0 +1,39 @@
+dtk_require_common_commands('thor/common')
+module DTK::Client
+  module CloneMixin
+    extend Console
+    include CommonMixin
+    ##
+    #
+    # internal_trigger: this flag means that other method (internal) has trigger this.
+    #                   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={})
+      module_name,repo_url,branch,not_ok_response = workspace_branch_info(module_type,module_id,version,opts)
+      return not_ok_response if not_ok_response
+      response = Helper(:git_repo).create_clone_with_branch(module_type,module_name,repo_url,branch,version,opts)
+
+      if response.ok?
+        puts "Module '#{module_name}' has been successfully cloned!" unless omit_output
+        unless internal_trigger
+          if Console.confirmation_prompt("Would you like to edit cloned module now?")
+            if module_type.to_s.start_with?("service")
+              context_params_for_module = create_context_for_module(module_name, :"service-module")
+            else
+              context_params_for_module = create_context_for_module(module_name, :"component-module")
+            end
+            return edit(context_params_for_module)
+          end
+        end
+      end
+      response
+    end
+
+    def create_context_for_module(module_name, module_type)
+      context_params_for_module = DTK::Shell::ContextParams.new
+      context_params_for_module.add_context_to_params(module_name, "#{module_type}", module_name)
+      return context_params_for_module
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module DTK::Client
+  module CommonMixin
+   private
+    #returns module_name,repo_url,branch,not_ok_response( only if error)
+    def workspace_branch_info(module_type,module_id,version,opts={})
+      if info = opts[:workspace_branch_info]
+        [info[:module_name],info[:repo_url],info[:branch]]
+      else
+        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,response]
+        else
+          response.data(:module_name,:repo_url,:workspace_branch)
+        end
+      end
+    end
+
+    def get_workspace_branch_info_post_body(module_type,module_id,version_explicit,opts={})
+      id_field = "#{module_type}_id"
+      post_body = {
+        id_field => module_id
+      }
+      assembly_module = opts[:assembly_module]
+      if version = version_explicit||(assembly_module && assembly_module[:version])
+        post_body.merge!(:version => version) 
+      end
+      if assembly_module
+        post_body.merge!(:assembly_module => true,:assembly_name => assembly_module[:assembly_name])
+      end
+      post_body
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+dtk_require_common_commands('thor/clone')
+dtk_require_common_commands('thor/push_clone_changes')
+dtk_require_common_commands('thor/pull_clone_changes')
+dtk_require_common_commands('thor/reparse')
+require 'yaml'
+
+module DTK::Client
+  module EditMixin
+    include CloneMixin
+    include PushCloneChangesMixin
+    include PullCloneChangesMixin
+    include ReparseMixin
+
+    ##
+    #
+    # module_type: will be one of 
+    # :component_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 
+      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
+          omit_output = true
+          response = clone_aux(module_type,module_id,version,internal_trigger,omit_output,opts)
+          # if error return
+          return response unless response.ok?
+          pull_if_needed = false
+        else
+          # user choose not to clone needed module
+          return
+        end
+      end
+      # here we should have desired module cloned
+
+      if pull_if_needed
+        response = pull_clone_changes?(module_type,module_id,version,opts)
+        return response unless response.ok?
+      end
+      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 = 
+          if edit_info.kind_of?(String)
+            edit_info
+          else #edit_info.kind_of?(Hash) and has key :base_file_name
+            base_file = edit_info[:base_file_name]
+            (File.exists?("#{module_location}/#{base_file}.yaml") ? "#{base_file}.yaml" : "#{base_file}.json")
+          end
+        OsUtil.edit("#{module_location}/#{file_to_edit}")
+        OsUtil.print("If you want to use different editor please set environment variable EDITOR and log back into dtk-shell!", :yellow) unless ENV['EDITOR']
+      else
+        Console.unix_shell(module_location, module_id, module_type, version)
+      end
+
+      unless grit_adapter.changed?
+        puts "No changes to repository"
+        return Response::Ok.new()
+      end
+
+      unless file_to_edit
+        grit_adapter.print_status
+      end
+
+      # check to see if auto commit flag
+      auto_commit  = ::DTK::Configuration.get(:auto_commit_changes)
+      confirmed_ok = false
+
+      # if there is no auto commit ask for confirmation
+      unless auto_commit
+        confirm_msg = 
+          if file_to_edit
+            "Would you like to commit changes to the file?"
+          else
+            "Would you like to commit and push ALL the changes?"
+          end
+        confirmed_ok = Console.confirmation_prompt(confirm_msg)
+      end
+
+      if (auto_commit || confirmed_ok)
+        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")
+        internal_trigger=true
+        reparse_aux(module_location)
+        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        
+      #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
+
+    def attribute_header()
+      header_string = 
+      "#############################\n####  REQUIRED ATTRIBUTES\n#############################\n#\n"
+    end
+
+    def attributes_editor(attributes,format)
+      if (format.eql?('yaml'))
+        dtk_folder = OsUtil.dtk_local_folder
+        file_path = "#{dtk_folder}/temp_attrs.yaml"
+
+        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 
+            attribute_pairs[k] = nil
+            v = nil
+          end
+
+          first_iteration_values << v
+        end
+
+        File.open(file_path, 'w') do |out|
+          # print out required attributes
+          unless required_attributes.empty?
+            out.write(attribute_header())
+            required_attributes.each do |req_attr|
+              out.write("##{req_attr}\n")
+            end
+            out.write("#\n")
+          end
+
+          YAML.dump(attribute_pairs, out)
+        end
+
+        OsUtil.edit(file_path)
+        OsUtil.print("If you want to use different editor please set environment variable EDITOR and log back into dtk-shell!", :yellow) unless ENV['EDITOR']
+        begin
+          edited = YAML.load_file(file_path)
+        rescue Psych::SyntaxError => e
+          raise DTK::Client::DSLParsing::YAMLParsing.new("YAML parsing error #{e} in file",file_path)
+        end
+
+        edited.each do |k,v|
+          second_iteration_keys << k
+          second_iteration_values << v
+        end
+
+        unless first_iteration_keys == second_iteration_keys
+          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
+        raise DTK::Client::DtkValidationError, "Unsupported format type '#{format.to_s}'!"
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,84 @@
+module DTK::Client
+  module ListDiffsMixin
+  	def list_diffs_aux(module_type,module_id,remote,version=nil)
+  		id_field    = "#{module_type}_id"
+      path_to_key = SshProcessing.default_rsa_pub_key_path()
+      rsa_pub_key = File.file?(path_to_key) && File.open(path_to_key){|f|f.read}.chomp
+
+      post_body = {
+        id_field => module_id,
+        :access_rights => "r",
+        :action => "pull"
+      }
+      post_body.merge!(:version => version) if version
+      post_body.merge!(:rsa_pub_key => rsa_pub_key) if rsa_pub_key
+
+      response = post(rest_url("#{module_type}/get_remote_module_info"),post_body)
+      return response unless response.ok?
+      
+      module_name = response.data(:module_name)
+      opts = {
+        :remote_repo_url => response.data(:remote_repo_url),
+        :remote_repo => response.data(:remote_repo),
+        :remote_branch => response.data(:remote_branch),
+        :local_branch => response.data(:workspace_branch)
+      }
+      version = response.data(:version)
+
+      response = Helper(:git_repo).get_diffs(module_type,module_name,version,opts)
+      return response unless response.ok?
+
+      added, deleted, modified = print_diffs(response.data(remote ? :diffs : :status), remote)
+
+      raise DTK::Client::DtkValidationError, "There is no changes in current workspace!" if(added.empty? && deleted.empty? && modified.empty?)
+      
+      unless added.empty?
+        puts "ADDED:"
+        added.each do |a|
+          puts "\t #{a.inspect}"
+        end
+      end
+
+      unless deleted.empty?
+        puts "DELETED:"
+        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 print_diffs(response, remote)
+      added    = []
+      deleted  = []
+      modified = []
+
+      unless response[:files_modified].nil?
+        response[:files_modified].each do |file|
+          modified << file[:path]
+        end
+      end
+
+      unless response[:files_deleted].nil?
+        response[:files_deleted].each do |file|
+          deleted << file[:path]
+        end
+      end
+
+      unless response[:files_added].nil?
+        response[:files_added].each do |file|
+          added << file[:path]
+        end
+      end
+
+      return added, deleted, modified
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+dtk_require_common_commands('thor/common')
+module DTK::Client
+  module PullCloneChangesMixin
+    def pull_clone_changes?(module_type,module_id,version=nil,opts={})
+      module_name,repo_url,branch,not_ok_response = workspace_branch_info(module_type,module_id,version,opts)
+      return not_ok_response if not_ok_response
+      Helper(:git_repo).pull_changes(module_type,module_name,opts.merge(:local_branch => branch))
+    end
+  end
+end
+

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

@@ -0,0 +1,99 @@
+module DTK::Client
+  module PullFromRemoteMixin
+
+    ##
+    #
+    # module_type: will be :component_module or :service_module
+    def import_module_component_dependencies(module_id)
+      post_body = {
+        :service_module_id => module_id
+      }
+      response = post(rest_url("service_module/resolve_pull_from_remote"),post_body)
+
+      print "Resolving dependencies please wait ... "
+      
+      if (response.ok? && !(missing_components = response.data(:missing_modules)).empty?)
+        puts " New dependencies found, Installing."
+
+        trigger_module_component_import(missing_components)
+        puts "Resuming pull from remote ..."
+      else
+        puts 'Done.'
+      end
+    end
+
+    def pull_from_remote_aux(module_type,module_id,version=nil)
+      #get remote module info, errors raised if remote is not linked or access errors
+      path_to_key = SshProcessing.default_rsa_pub_key_path()
+      rsa_pub_key = File.file?(path_to_key) && File.open(path_to_key){|f|f.read}.chomp
+
+      post_body = {
+        PullFromRemote.id_field(module_type) => module_id,
+        :access_rights => "r",
+        :action => "pull"
+      }
+      post_body.merge!(:version => version) if version
+      post_body.merge!(:rsa_pub_key => rsa_pub_key) if rsa_pub_key
+      response = post(rest_url("#{module_type}/get_remote_module_info"),post_body)      
+      return response unless response.ok?
+      module_name = response.data(:module_name)
+      remote_params = response.data_hash_form(:remote_repo_url,:remote_repo,:remote_branch)
+      remote_params.merge!(:version => version) if version
+
+      #check and import component module dependencies before importing service itself
+      import_module_component_dependencies(module_id) if (module_type == :service_module)
+
+      # check whether a local module exists to determine whether pull from local clone or try to pull from server
+      if Helper(:git_repo).local_clone_exists?(module_type,module_name,version)
+        unless rsa_pub_key
+          raise DtkError,"No File found at (#{path_to_key}). Path is wrong or it is necessary to generate the public rsa key (e.g., run ssh-keygen -t rsa)"
+        end
+        PullFromRemote.perform_locally(self,module_type,module_id,module_name,remote_params)
+      else
+        PullFromRemote.perform_on_server(self,module_type,module_id,module_name,remote_params)
+      end
+    end
+   private
+    module PullFromRemote 
+      extend CommandBase
+      def self.perform_locally(cmd_obj,module_type,module_id,module_name,remote_params)
+        opts = remote_params
+        response = cmd_obj.Helper(:git_repo).pull_changes(module_type,module_name,opts)
+        # return response unless response.ok?
+
+        if response.data[:diffs].empty?
+          raise DtkError, "No changes to pull from remote"
+        end
+
+        return response
+        
+        # removing this for now, because we will use push-clone-changes as part of pull-from-remote command 
+        # post_body = {
+        #   id_field(module_type) => module_id,
+        #   :commit_sha => response.data[:commit_sha],
+        #   :json_diffs => JSON.generate(response.data[:diffs])
+        # }
+        # post rest_url("#{module_type}/update_model_from_clone"), post_body
+      end
+
+      def self.perform_on_server(cmd_obj,module_type,module_id,module_name,remote_params)
+        post_body = {
+          id_field(module_type) => module_id,
+          :remote_repo => remote_params[:remote_repo],
+          :module_name => module_name
+        }
+        post_body.merge!(:version => remote_params[:version]) if remote_params[:version]
+        response = post rest_url("#{module_type}/pull_from_remote"), post_body
+        
+        
+        puts "You have successfully pulled code on server instance." if response.ok?
+        response
+      end
+      
+      def self.id_field(module_type)
+        "#{module_type}_id"
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,45 @@
+dtk_require_common_commands('thor/common')
+dtk_require_from_base('command_helpers/service_importer')
+
+module DTK::Client
+  module PushCloneChangesMixin
+    include CommonMixin
+    ##
+    #
+    # module_type: will be :component_module or :service_module 
+    def push_clone_changes_aux(module_type,module_id,version,commit_msg,internal_trigger=false,opts={})
+      module_name,repo_url,branch,not_ok_response = workspace_branch_info(module_type,module_id,version,opts)
+      return not_ok_response if not_ok_response
+
+      push_opts = opts.merge(:commit_msg => commit_msg, :local_branch => branch)
+      response = Helper(:git_repo).push_changes(module_type,module_name,version,push_opts)
+      return response unless response.ok?
+
+      json_diffs = (response.data(:diffs).empty? ? {} : JSON.generate(response.data(:diffs)))
+      commit_sha = response.data(:commit_sha)
+      repo_obj = response.data(:repo_obj)
+      json_diffs = JSON.generate(response.data(:diffs))
+      post_body = get_workspace_branch_info_post_body(module_type,module_id,version,opts).merge(:json_diffs => json_diffs, :commit_sha => commit_sha)
+      post_body.merge!(:modification_type => opts[:modification_type]) if opts[:modification_type]
+      post_body.merge!(:force_parse => true) if options['force-parse']
+
+      response = post(rest_url("#{module_type}/update_model_from_clone"),post_body)
+      return response unless response.ok?
+      
+      if (!response.data.empty? && response.data(:dsl_parsed_info))
+        dsl_parsed_message = ServiceImporter.error_message(module_name, response.data(:dsl_parsed_info))
+        DTK::Client::OsUtil.print(dsl_parsed_message, :red) 
+        return Response::NoOp.new() #NoOp fine because error reported by section above
+      end
+      
+      if module_type == :component_module
+        dsl_created_info = response.data(:dsl_created_info)
+        if dsl_created_info and !dsl_created_info.empty?
+          msg = "A #{dsl_created_info["path"]} file has been created for you, located at #{repo_obj.repo_dir}"
+          return Helper(:git_repo).add_file(repo_obj,dsl_created_info["path"],dsl_created_info["content"],msg)
+        end
+      end
+      Response::Ok.new()
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module DTK::Client
+  module PushToRemoteMixin
+
+    ##
+    #
+    # module_type: will be :component_module or :service_module
+
+    def push_to_remote_aux(module_type,module_id, module_name,remote_namespace,version=nil)       
+      id_field = "#{module_type}_id"
+
+      rsa_pub_value = SshProcessing.rsa_pub_key_content()
+
+      post_body = {
+        id_field => module_id,
+        :rsa_pub_key => rsa_pub_value,
+        :access_rights => "rw",
+        :action => "push"
+      }
+      post_body.merge!(:version => version) if version
+      post_body.merge!(:remote_namespace => remote_namespace) if remote_namespace
+      response = post(rest_url("#{module_type}/get_remote_module_info"),post_body)
+
+      return response unless response.ok?
+
+      returned_module_name = response.data(:module_name)
+      opts = {
+        :remote_repo_url => response.data(:remote_repo_url),
+        :remote_repo => response.data(:remote_repo),
+        :remote_branch => response.data(:remote_branch),
+        :local_branch => response.data(:workspace_branch)
+      }
+
+      version = response.data(:version)
+
+      response = Helper(:git_repo).push_changes(module_type,returned_module_name,version,opts)
+      return response unless response.ok?
+      if response.data(:diffs).empty?
+        raise DtkError, "No changes to push"
+      end
+      
+      Response::Ok.new()
+    end
+
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'json'
+require 'yaml'
+
+module DTK::Client
+  module ReparseMixin
+
+    ##
+    #
+    # module_type: will be :component_module or :service_module
+    def reparse_aux(location)
+      files_json = Dir.glob("#{location}/**/*.json")
+      files_yaml = Dir.glob("#{location}/**/*.yaml")
+
+      files_json.each do |file|
+        file_content = File.open(file).read
+        begin 
+          JSON.parse(file_content)
+        rescue JSON::ParserError => e
+          raise DTK::Client::DSLParsing::JSONParsing.new("JSON parsing error #{e} in file",file)
+        end
+      end
+
+      files_yaml.each do |file|
+        file_content = File.open(file).read
+        begin 
+          YAML.load(file_content)
+        rescue Exception => e
+          raise DTK::Client::DSLParsing::YAMLParsing.new("YAML parsing error #{e} in file",file)
+        end
+      end
+      
+      Response::Ok.new()
+    end
+
+  end
+end

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

@@ -0,0 +1,29 @@
+module DTK::Client
+  module SetRequiredParamsMixin
+    def set_required_params_aux(id,type,subtype=nil)
+      id_field = "#{type}_id".to_sym
+      post_body = {
+        id_field => id,
+        :subtype     => 'instance',
+        :filter      => 'required_unset_attributes'
+      }
+      post_body.merge!(:subtype => subtype.to_s) if subtype
+      response = post rest_url("#{type}/get_attributes"), post_body
+      return response unless response.ok?
+      missing_params = response.data
+      if missing_params.empty?
+        response.set_data('Message' => "No parameters to set.")
+        response
+      else
+        param_bindings = DTK::Shell::InteractiveWizard.resolve_missing_params(missing_params)
+        post_body = {
+          id_field => id,
+          :av_pairs_hash => param_bindings.inject(Hash.new){|h,r|h.merge(r[:id] => r[:value])}
+        }
+        response = post rest_url("#{type}/set_attributes"), post_body
+        return response unless response.ok?
+        response.data
+      end
+    end
+  end
+end