dtk-client 0.5.6.1

data/lib/shell.rb

@@ -0,0 +1,219 @@
+require File.expand_path('client',                  File.dirname(__FILE__))
+require File.expand_path('parser/adapters/thor',    File.dirname(__FILE__))
+require File.expand_path('commands/thor/dtk',       File.dirname(__FILE__))
+require File.expand_path('error',                   File.dirname(__FILE__))
+
+# load all from shell directory since those are required
+Dir[File.expand_path('shell/*.rb', File.dirname(__FILE__))].each { |file| require file }
+
+require 'shellwords'
+require 'readline'
+require 'colorize'
+require 'thor'
+
+# ideas from http://bogojoker.com/readline/#trap_sigint_and_restore_the_state_of_the_terminal
+
+# GLOBAL IDENTIFIER
+$shell_mode = true
+
+ALIAS_COMMANDS = {
+  'ls' => 'list', 
+  'cd' => 'cc',
+  'rm' => 'delete'
+}
+
+# METHODS
+
+# support for alias commands (ls for list, cd for cc etc.)
+def preprocess_commands(original_command)
+  command = ALIAS_COMMANDS[original_command]
+  # return command if alias for specific command exist in predefined ALIAS_COMMANDS
+  # else return entered command because there is no alias for it
+  return (command.nil? ? original_command : command)
+end
+# RUNTIME PART - STARTS HERE
+
+def run_shell_command()
+  # init shell client
+  init_shell_context()
+
+  # prompt init
+  prompt = DTK::Shell::Context::DTK_ROOT_PROMPT
+
+  # trap CTRL-C and remove current text without leaving the dtk-shell
+  trap("INT"){
+    puts "\n"
+    raise Interrupt
+  }
+  
+  # runtime part
+  begin
+    while line = Readline.readline(prompt, true)
+      prompt = execute_shell_command(line, prompt) unless line.strip.empty?
+    end
+  rescue DTK::Shell::ExitSignal => e
+    # do nothing
+  rescue ArgumentError => e
+    puts e.backtrace if ::DTK::Configuration.get(:development_mode)
+    retry
+  rescue Interrupt => e
+    #system('stty', stty_save) # Restore
+    retry
+  rescue Exception => e
+    DtkLogger.instance.error_pp("[CLI INTERNAL ERROR] #{e.message}", e.backtrace)
+  ensure
+    puts "\n" unless e.is_a? DTK::Shell::ExitSignal
+    # logout
+    DTK::Client::Session.logout()
+    # save users history
+    DTK::Shell::Context.save_session_history(Readline::HISTORY.to_a)
+    exit!
+  end
+end
+
+def init_shell_context()
+  begin
+    @context      = DTK::Shell::Context.new
+    @shell_header = DTK::Shell::HeaderShell.new
+    # loads root context 
+    @context.load_context()
+
+    @t1   = nil
+    Readline.completion_append_character=''
+    DTK::Shell::Context.load_session_history().each do |c|
+      Readline::HISTORY.push(c)
+    end
+
+  rescue DTK::Client::DtkError => e
+    DtkLogger.instance.error(e.message, true)
+    puts "Exiting ..."
+    raise DTK::Shell::ExitSignal
+  end
+end
+
+def execute_shell_command(line, prompt)
+   begin
+    # remove single/double quotes from string because shellwords module is not able to parse it
+    line.gsub!(/['"]/, '')
+
+    # some special cases
+    raise DTK::Shell::ExitSignal if line == 'exit'
+    return prompt if line.empty?
+    if line == 'clear'
+      DTK::Client::OsUtil::clear_screen
+      return prompt
+    end
+    # when using help on root this is needed
+    line = 'dtk help' if (line == 'help' && @context.root?)
+
+    args = Shellwords.split(line)
+    cmd = args.shift
+
+    # support command alias (ls for list etc.)
+    cmd = preprocess_commands(cmd)
+
+    # DEV only reload shell
+    if ::DTK::Configuration.get(:development_mode)
+      if ('restart' == cmd)
+        puts "DEV Reloading shell ..."
+        ::DTK::Client::OsUtil.dev_reload_shell()
+        return prompt
+      end
+    end
+
+    
+    if ('cc' == cmd)
+      # in case there is no params we just reload command
+      args << "/" if args.empty?      
+      prompt = @context.change_context(args, cmd)
+    elsif ('popc' == cmd)
+        @context.dirs.shift()
+        args << (@context.dirs.first.nil? ? '/' : @context.dirs.first)
+        prompt = @context.change_context(args, cmd)
+    elsif ('pushc' == cmd)
+      if args.empty?
+        args << (@context.dirs[1].nil? ? '/' : @context.dirs[1])
+        @context.dirs.unshift(args.first)
+        @context.dirs.uniq!
+        prompt = @context.change_context(args, cmd)
+      else
+        prompt = @context.change_context(args)
+        # using regex to remove dtk: and > from path returned by change_context
+        # e.g transform dtk:/assembly/node> to /assembly/node
+        full_path = prompt.match(/[dtk:](\/.*)[>]/)[1]
+        @context.dirs.unshift(full_path)
+      end
+    elsif ('dirs' == cmd)
+      puts @context.dirs.inspect
+    else
+
+      # get all next-context-candidates (e.g. for assembly get all assembly_names)
+      context_candidates = @context.get_ac_candidates_for_context(@context.active_context.last_context(), @context.active_context())
+      
+      # this part of the code is used for calling of nested commands from base context (dtk:/>assembly/assembly_id converge)
+      # base_command is used to check if first command from n-level is valid e.g. 
+      # (dtk:/>assembly/assembly_id converge - chech if 'assembly' exists in context_candidates)
+      # revert_context is used to return to context which command is called from after command is executed
+      base_command = cmd.split('/').first
+      revert_context = false
+
+      if context_candidates.include?(base_command)
+        @context.change_context([cmd])
+        cmd = args.shift
+        revert_context = true
+      end
+
+      if cmd.nil?
+        prompt = @context.change_context(["-"]) if revert_context
+        raise DTK::Client::DtkValidationError, "You have to provide command after context name. Usage: CONTEXT-TYPE/CONTEXT-NAME COMMAND [ARG1] .. [ARG2]." 
+      end
+
+      # send monkey patch class information about context
+      Thor.set_context(@context)
+      
+      # we get command and hash params, will return Validation error if command is not valid
+      entity_name, method_name, context_params, thor_options, invalid_options = @context.get_command_parameters(cmd,args)
+
+      # check if command is executed from parent context (e.g assembly_name list-nodes)
+      if context_candidates.include?(method_name)
+        context_params.add_context_to_params(method_name, entity_name, method_name)
+        method_name = context_params.method_arguments.shift if context_params.method_arguments.size > 0
+      else        
+        unless @context.method_valid?(method_name)
+          prompt = @context.change_context(["-"]) if revert_context
+          raise DTK::Client::DtkValidationError, "Method '#{method_name}' is not valid in current context."
+        end
+      end
+
+      # raise validation error if option is not valid
+      raise DTK::Client::DtkValidationError.new("Option '#{invalid_options.first||method_name}' is not valid for current command!", true) unless invalid_options.empty?
+
+      # execute command via Thor
+      top_level_execute(entity_name, method_name, context_params, thor_options, true)
+
+      # when 'delete' or 'delete-and-destroy' command is executed reload cached tasks with latest commands
+      unless (args.nil? || args.empty?)
+        @context.reload_cached_tasks(entity_name) if (method_name.include?('delete') || method_name.include?('import'))
+      end       
+
+      # check execution status, prints status to sttout
+      DTK::Shell::StatusMonitor.check_status()
+
+      # after nested command called from base context is executed successfully, return to context which command is executed from
+      # this is the same as 'cd -' command is executed
+      prompt = @context.change_context(["-"]) if revert_context
+    end
+  rescue DTK::Client::DSLParsing => e
+    DTK::Client::OsUtil.print(e.message, :red)
+  rescue DTK::Client::DtkValidationError => e
+    DTK::Client::OsUtil.print(e.message, :yellow)
+  rescue DTK::Shell::Error => e
+    DtkLogger.instance.error(e.message, true)
+  end
+  
+  return prompt
+end
+
+
+
+

data/lib/util/console.rb

@@ -0,0 +1,143 @@
+require 'readline'
+require 'shellwords'
+
+dtk_require("os_util")
+dtk_require_common_commands('../common/thor/push_clone_changes')
+dtk_require_common_commands('../common/thor/reparse')
+dtk_require_from_base("command_helper")
+
+module DTK::Client
+  module Console
+    class << self
+      include PushCloneChangesMixin
+      include ReparseMixin
+      include CommandBase
+      include CommandHelperMixin
+
+      # Display confirmation prompt and repeat message until expected answer is given
+      def confirmation_prompt(message, add_options=true)
+        # used to disable skip with ctrl+c
+        trap("INT", "SIG_IGN")
+        message += " (yes|no)" if add_options
+
+        while line = Readline.readline("#{message}: ", true)
+          if (line.eql?("yes") || line.eql?("y"))
+            trap("INT",false)
+            return true
+          elsif (line.eql?("no") || line.eql?("n"))
+            trap("INT",false)
+            return false
+          end
+        end
+      end
+
+      # Loading output used to display waiting status
+      def wait_animation(message, time_seconds)
+        print message
+        print " [     ]"
+        STDOUT.flush
+        time_seconds.downto(1) do
+          1.upto(4) do |i|
+            next_output = "\b\b\b\b\b\b\b"
+            case
+             when i % 4 == 0
+              next_output  += "[ =   ]"
+             when i % 3 == 0
+               next_output += "[  =  ]"
+             when i % 2 == 0
+              next_output  += "[   = ]"
+             else
+              next_output  += "[  =  ]"
+            end
+
+            print next_output
+            STDOUT.flush
+            sleep(0.25)
+          end
+        end
+        # remove loading animation
+        print "\b\b\b\b\b\b\bRefreshing..."
+        STDOUT.flush
+        puts 
+      end
+
+
+      ##
+      # Method that will execute until interupted as unix like shell. As input takes
+      # path to desire directory from where unix shell can execute normaly.
+      #
+      def unix_shell(path,module_id,module_type,version=nil)
+        
+        dtk_shell_ac_proc = Readline.completion_proc
+        dtk_shell_ac_append_char = Readline.completion_append_character
+
+        if OsUtil.is_windows?
+          puts "[NOTICE] Shell interaction is currenly not supported on Windows."
+          return
+        end
+        
+        begin
+          # we need to change path like this since system call 'cd' is not supported
+          initial_dir = Dir.pwd
+          Dir.chdir(path)
+          puts "[NOTICE] You are switching to unix-shell, to path #{path}"
+
+          prompt = DTK::Client::OsUtil.colorize("$dtk:unix-shell ", :yellow)
+          Readline.completion_append_character = ""
+          Readline.completion_proc = Proc.new do |str|
+            Dir[str+'*'].grep(/^#{Regexp.escape(str)}/)
+          end
+          while line = Readline.readline("#{prompt}#{Dir.getwd()}>", true)
+            begin
+              line = line.chomp()
+              break if line.eql?('exit')
+              # since we are not able to support cd command due to ruby specific restrictions
+              # we will be using chdir to this.
+              if (line.match(/^cd /))
+                 # remove cd part of command
+                line = line.gsub(/^cd /,'')
+                # Get path
+                path = line.match(/^\//) ? line : "#{Dir.getwd()}/#{line}"
+                # If filepat* with '*' at the end, match first directory and go in it, else try to change original input
+                if path.match(/\*$/)
+                  dirs = Dir[path].select{|file| File.directory?(file)} 
+                  unless dirs.empty?
+                    Dir.chdir(dirs.first)
+                    next
+                  end
+                end
+                # Change directory
+                Dir.chdir(path)
+              elsif line.match(/^dtk-push-changes/)
+                args       = Shellwords.split(line)
+                commit_msg = nil
+
+                unless args.size==1
+                  raise DTK::Client::DtkValidationError, "To push changes to server use 'dtk-push-changes [-m COMMIT-MSG]'" unless (args[1]=="-m" && args.size==3)
+                  commit_msg = args.last
+                end
+
+                reparse_aux(path)
+                push_clone_changes_aux(module_type, module_id, version, commit_msg)
+              else
+                system(line)        
+              end
+            rescue Exception => e
+              DtkLogger.instance.error_pp(e.message, e.backtrace)
+            end
+          end
+         rescue Interrupt
+          puts ""
+          # do nothing else
+         ensure
+          Dir.chdir(initial_dir)
+        end
+
+        Readline.completion_append_character = dtk_shell_ac_append_char unless dtk_shell_ac_append_char.nil?
+        Readline.completion_proc = dtk_shell_ac_proc unless dtk_shell_ac_proc.nil?
+        puts "[NOTICE] You are leaving unix-shell."
+      end
+
+    end
+  end
+end

data/lib/util/dtk_puppet.rb

@@ -0,0 +1,46 @@
+module DTK
+  module Client
+    #
+    # Class is used as puppet wrapper, at the moment it will use console comamnds, later
+    # to be replaced with direct usage of puppet code, or re-implentation of their direct calls 
+    #
+    class DtkPuppet
+
+      MODULE_PATH = OsUtil.module_clone_location()
+
+      # installs puppet module from puppet forge via puppet module
+      # method will print out progress or errrors
+      #
+      # Returns: Name of directory where module is saved
+      def self.install_module(module_name)
+        output = nil
+        
+        OsUtil.suspend_output do
+          output = `puppet module install #{module_name} --modulepath #{MODULE_PATH} --force --render-as json`
+        end
+      
+        # extract json from output, regex will match json in string
+        matched = output.match(/\{.+\}/)
+
+        raise DTK::Client::DtkError, "Puppet module '#{module_name}' not found." unless matched
+        
+        # parse matched json
+        result = JSON.parse(matched[0])
+
+        if result['result'] == 'failure'
+          # we remove puppet specific messages
+          filtered = result['error']['multiline'].gsub(/^.*puppet module.*$\n?/,'')
+          # we strip and join multiline message
+          filtered = filtered.split(/\n/).map(&:strip).join(', ')
+          raise DTK::Client::DtkError, filtered
+        end
+        
+        # puppet uses last part of the module name, as dir for location
+        dir_name = module_name.split('-').last
+        puts "Successfully installed '#{module_name}' from puppet forge, location: '#{MODULE_PATH}/#{dir_name}'"
+        return dir_name
+      end
+      
+    end
+  end
+end

data/lib/util/os_util.rb

@@ -0,0 +1,265 @@
+dtk_require_from_base('domain/response')
+dtk_require_from_base('auxiliary')
+require 'highline'
+
+module DTK
+  module Client
+    module OsUtil
+
+      extend Auxiliary
+
+      class << self
+        def is_mac?
+          RUBY_PLATFORM.downcase.include?('darwin')
+        end
+
+        def is_windows?
+          RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+        end
+
+        def is_linux?
+          RUBY_PLATFORM.downcase.include?('linux')
+        end
+
+        def get_temp_location
+          is_windows? ? genv(:temp) : '/tmp'
+        end
+
+        def get_log_location
+          return "#{dtk_local_folder}"
+        end
+
+        def clear_screen
+          command = is_windows? ? "cls" : "clear"
+          system(command)
+        end
+
+        def dtk_home_dir
+          return "#{home_dir}"
+        end
+
+        # This will return class object from DTK::Client namespace
+        def get_dtk_class(command_name)
+          begin
+            Object.const_get('DTK').const_get('Client').const_get(cap_form(command_name))
+          rescue Exception => e
+            return nil
+          end
+        end
+
+        # for Windows app folder is already under OS username
+        def dtk_user_app_folder
+          if is_windows?
+            dtk_app_folder()
+          else
+            "#{dtk_app_folder}#{::DTK::Common::Aux.running_process_user()}/"
+          end
+        end
+
+        def dtk_app_folder
+          return (is_windows? ? "#{genv(:homedrive)}#{genv(:homepath)}/dtk/" : "#{/etc/}dtk/")
+        end
+
+        def dtk_local_folder
+          return (is_windows? ? "#{genv(:homedrive)}#{genv(:homepath)}/dtk/" : "#{home_dir}/dtk/")
+        end
+
+        def home_dir
+          return (is_windows? ? "#{genv(:homedrive)}#{genv(:homepath)}" : "#{genv(:home)}")
+        end
+
+        def genv(name)
+          return ENV[name.to_s.upcase].gsub(/\\/,'/')
+        end
+
+        def edit(file)
+          editor = ENV['EDITOR']
+          if is_windows?
+            raise Client::DtkError, "Environment variable EDITOR needs to be set; exit dtk-shell, set variable and log back into dtk-shell." unless editor
+          else
+            editor = 'vim' unless editor
+          end
+
+          system("#{editor} #{file}")
+        end
+        
+        def module_location(module_type,module_name,version=nil,opts={})
+          #compact used because module_name can be nil
+          module_location_parts(module_type,module_name,version,opts).compact.join('/')
+        end
+        
+        #if module location is /a/b/d/mod it returns ['/a/b/d','mod']
+        def module_location_parts(module_type,module_name,version=nil,opts={})
+          base_path = clone_base_path(opts[:assembly_module] ? :assembly_module : module_type)
+          if assembly_module = opts[:assembly_module]
+            assembly_name = opts[:assembly_module][:assembly_name]
+            base_all_types = "#{base_path}/#{assembly_name}"
+            if module_type == :all
+              [base_all_types,nil]
+            else
+              type = clone_base_path(module_type).split('/').last
+              ["#{base_all_types}/#{type}", module_name]
+            end
+          else
+            [base_path, "#{module_name}#{version && "-#{version}"}"]
+          end
+        end
+
+        def module_version_locations(module_type,module_name,version=nil,opts={})
+          base_path = module_location_parts(module_type,module_name,version,opts).first
+          module_versions = Dir.entries(base_path).select{|a| a.match(/^#{module_name}-\d.\d.\d$/)}
+          module_versions.map{|version|"#{base_path}/#{version}"}
+        end
+
+        def module_clone_location()
+          clone_base_path(:component_module)
+        end
+
+        def service_clone_location()
+          clone_base_path(:service_module)
+        end
+
+        def assembly_module_base_location()
+          clone_base_path(:assembly_module)
+        end
+
+        def clone_base_path(module_type)
+
+          path = 
+            case module_type
+              when :service_module then Config[:service_location]
+              when :component_module then Config[:module_location]
+              when :assembly_module then Config[:assembly_module_base_location]
+              else raise Client::DtkError, "Unexpected module_type (#{module_type})"
+            end
+
+
+          final_path = path && path.start_with?('/') ? path : "#{dtk_local_folder}#{path}"
+          # remove last slash if set in configuration by mistake
+          final_path.gsub(/\/$/,'')
+        end
+        private :clone_base_path
+        #
+        #
+        #
+        def local_component_module_list()
+          component_module_dir = module_clone_location()
+          Dir.entries(component_module_dir).select {|entry| File.directory? File.join(component_module_dir,entry) and !(entry =='.' || entry == '..') }
+        end
+        
+        # Public method will convert given string, to string with colorize output
+        #
+        # message - String to be colorized
+        # color   - Symbol describing color to be used
+        # 
+        # Returns String with colorize output
+        def colorize(message, color)
+          # at the moment we do not support colors in windows
+          ((is_windows? || message.nil?) ? message : message.colorize(color))
+        end
+
+        # Public method will print to STDOUT with given color
+        #
+        # message - String to be colorize and printed
+        # color   - Symbol describing the color to be used on STDOUT
+        #
+        # Void
+        def print(message, color)
+          puts colorize(message, color)
+        end
+
+        # Public block, method will suspend STDOUT, STDERR in body of it
+        #
+        # Example
+        # suspend_output do
+        #   # some calls 
+        # end
+        def suspend_output
+          if is_windows?
+            retval = yield
+          else
+            begin
+              orig_stderr = $stderr.clone
+              orig_stdout = $stdout.clone
+              $stderr.reopen File.new('/dev/null', 'w')
+              $stdout.reopen File.new('/dev/null', 'w')
+              retval = yield
+            rescue Exception => e
+              $stdout.reopen orig_stdout
+              $stderr.reopen orig_stderr
+              raise e
+            ensure
+              $stdout.reopen orig_stdout
+              $stderr.reopen orig_stderr
+            end
+          end
+          retval
+        end
+
+        def which(cmd)
+          exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+            exts.each { |ext|
+              exe = File.join(path, "#{cmd}#{ext}")
+              return exe if File.executable? exe
+            }
+          end
+          return nil
+        end
+
+        def dev_reload_shell()
+          suspend_output do
+            load File.expand_path('../../lib/util/os_util.rb', File.dirname(__FILE__))
+            load File.expand_path('../../lib/shell/help_monkey_patch.rb', File.dirname(__FILE__))
+            load File.expand_path('../../lib/shell/domain.rb', File.dirname(__FILE__))
+            path = File.expand_path('../../lib/commands/thor/*.rb', File.dirname(__FILE__))
+            Dir[path].each do |thor_class_file|
+              load thor_class_file
+            end
+          end
+        end
+
+        def put_warning(prefix, text, color)
+          width = HighLine::SystemExtensions.terminal_size[0] - (prefix.length + 1)
+          text_split = wrap(text, width)
+          Kernel.print colorize(prefix, color), " "
+          text_split.lines.each_with_index do |line, index|
+            line = " "*(prefix.length + 1) + line unless index == 0
+            puts line
+          end
+        end
+
+        def wrap(text, wrap_at)
+          wrapped = [ ]
+          text.each_line do |line|
+          # take into account color escape sequences when wrapping
+          wrap_at = wrap_at + (line.length - actual_length(line))
+          while line =~ /([^\n]{#{wrap_at + 1},})/
+            search  = $1.dup
+            replace = $1.dup
+            if index = replace.rindex(" ", wrap_at)
+              replace[index, 1] = "\n"
+              replace.sub!(/\n[ \t]+/, "\n")
+              line.sub!(search, replace)
+            else
+              line[$~.begin(1) + wrap_at, 0] = "\n"
+            end
+          end
+          wrapped << line
+          end
+          return wrapped.join
+        end
+
+        def actual_length( string_with_escapes )
+         string_with_escapes.to_s.gsub(/\e\[\d{1,2}m/, "").length
+        end
+
+        private
+        
+        def seperator
+          return (is_windows? ? "\\" : "/")
+        end
+      end
+    end
+  end
+end

data/lib/view_processor/augmented_simple_list.rb

@@ -0,0 +1,27 @@
+#TODO: test for assembly list/display; want to make assembly specfic stuff datadriven
+dtk_require 'simple_list'
+module DTK
+  module Client
+    class ViewProcAugmentedSimpleList < ViewProcSimpleList
+     private
+      def initialize(type,command_class,data_type_index=nil)
+        super
+        @meta = get_meta(type,command_class)
+      end
+      def failback_meta(ordered_cols)
+        nil
+      end
+      def simple_value_render(ordered_hash,ident_info)
+        augmented_def?(ordered_hash,ident_info) || super
+      end
+      def augmented_def?(ordered_hash,ident_info)
+        return nil unless @meta
+        if aug_def =  @meta["#{ordered_hash.object_type}_def".to_sym]
+          ident_str = ident_str(ident_info[:ident]||0)
+          vals = aug_def[:keys].map{|k|ordered_hash[k.to_s]}
+          "#{ident_str}#{aug_def[:fn].call(*vals)}\n"
+        end
+      end
+    end
+  end
+end