dtk-client 0.9.1 → 0.10.0

data/lib/shell/status_monitor.rb

@@ -1,124 +0,0 @@
-#
-# 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.
-#
-# TODO-REMOVE: Check if we need this anymore
-
-require 'thread'
-require 'singleton'
-require 'colorize'
-#dtk_require('../commands')
-
-# This singleton is used to check status on running processes on the server side
-# Once certain task is complete it will give notice to user da certain task has been completed
-# At the moment this only
-
-module DTK
-  module Shell
-    class TaskStatusThread < Thread
-      attr_accessor :task_id, :finished, :status
-
-      def initialize
-        @finished = false
-        super
-      end
-    end
-
-    class StatusMonitor
-      include Singleton
-      include DTK::Client::CommandBase
-
-      THREAD_SLEEP_TIME = DTK::Configuration.get(:task_check_frequency)
-
-      def initialize
-        @threads        = []
-        @finished_tasks = []
-        @conn           = DTK::Client::Session.get_connection()
-      end
-
-      def self.start_monitoring(task_id)
-        self.instance.start_monitoring(task_id)
-      end
-
-      def self.check_status
-        self.instance.check_status
-      end
-
-      def check_status
-        @threads.each do |t|
-          if t.finished
-            @finished_tasks << t
-          end
-        end
-
-        # removes finished tasks from the main queue
-        @threads = @threads - @finished_tasks
-
-        @finished_tasks.each do |t|
-          puts ""
-          puts "[TASK NOTICE] Task with ID: #{t.task_id}, has finished with status: #{colorize_status(t.status)}"
-        end
-
-        @finished_tasks.clear
-      end
-
-      def start_monitoring(task_id)
-        puts "Client has started monitoring task [ID:#{task_id}]. You will be notified when task has been completed."
-        @threads << DTK::Shell::TaskStatusThread.new do
-          begin
-            response, post_hash_body = nil, {}
-            post_hash_body[:task_id] = task_id
-            DTK::Shell::TaskStatusThread.current.task_id = task_id
-
-            # pooling server for task status
-            while task_running?(response)
-              sleep(THREAD_SLEEP_TIME) unless response.nil?
-              response = post rest_url("task/status"),post_hash_body
-              # we break if there is error in response
-              break unless response.ok?
-            end
-
-            DTK::Shell::TaskStatusThread.current.finished = true
-
-            if response.ok?
-              DTK::Shell::TaskStatusThread.current.status = response.data['status'].upcase
-            else
-              DTK::Shell::TaskStatusThread.current.status = "RESPONSE NOT OK, RESPONSE: #{response}"
-            end
-
-          rescue Exception => e
-            DtkLogger.instance.error_pp("[THREAD ERROR] Error getting task status with message: #{e.message}", e.backtrace)
-          end
-        end
-      end
-
-      private
-
-      def colorize_status(status)
-        color = status.eql?('FAILED') ? :red : :green
-        return DTK::Client::OsUtil.colorize(status, color)
-      end
-
-      # return true   if status SUCCEDED, FAILED
-      # returns false if status EXECUTING
-      def task_running?(response)
-        return true if response.nil?
-        return !(response.data['status'].eql?("succeeded") || response.data['status'].eql?("failed"))
-      end
-
-    end
-  end
-end

data/lib/shell.rb

@@ -1,261 +0,0 @@
-#
-# 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.
-#
-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'
-}
-
-class MainContext
-  include Singleton
-
-  attr_accessor :context
-
-  def initialize
-    @context = DTK::Shell::Context.new
-  end
-
-  def self.get_context
-    MainContext.instance.context
-  end
-end
-
-# 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
-    retry
-  rescue Exception => e
-    client_internal_error = DTK::Client::DtkError::Client.label()
-    DtkLogger.instance.error_pp("[#{client_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
-    MainContext.get_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
-    if matched = line.scan(/['"]/)
-      line.gsub!(/['"]/, '') if matched.size.odd?
-    end
-
-    # 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' && MainContext.get_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 = MainContext.get_context.change_context(args, cmd)
-    elsif ('popc' == cmd)
-        MainContext.get_context.dirs.shift()
-        args << (MainContext.get_context.dirs.first.nil? ? '/' : MainContext.get_context.dirs.first)
-        prompt = MainContext.get_context.change_context(args, cmd)
-    elsif ('pushc' == cmd)
-      if args.empty?
-        args << (MainContext.get_context.dirs[1].nil? ? '/' : MainContext.get_context.dirs[1])
-        MainContext.get_context.dirs.unshift(args.first)
-        MainContext.get_context.dirs.uniq!
-        prompt = MainContext.get_context.change_context(args, cmd)
-      else
-        prompt = MainContext.get_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]
-        MainContext.get_context.dirs.unshift(full_path)
-      end
-    elsif ('dirs' == cmd)
-      puts MainContext.get_context.dirs.inspect
-    else
-
-      # get all next-context-candidates (e.g. for assembly get all assembly_names)
-      context_candidates = MainContext.get_context.get_ac_candidates_for_context(MainContext.get_context.active_context.last_context(), MainContext.get_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)
-        MainContext.get_context.change_context([cmd])
-        cmd = args.shift
-        revert_context = true
-      end
-
-      if cmd.nil?
-        prompt = MainContext.get_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(MainContext.get_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 = MainContext.get_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 MainContext.get_context.method_valid?(method_name)
-          prompt = MainContext.get_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
-      current_contex_path = MainContext.get_context.active_context.full_path
-      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?)
-        MainContext.get_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()
-
-      # if we change context while executing command, change prompt as well
-      unless current_contex_path.eql?(MainContext.get_context.active_context.full_path)
-        prompt = "dtk:#{MainContext.get_context.active_context.full_path}>"
-      end
-
-      # 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 = MainContext.get_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
-
-public
-
-def execute_shell_command_internal(line)
-  execute_shell_command(line, DTK::Shell::Context::DTK_ROOT_PROMPT)
-end

data/lib/task_status.rb

@@ -1,83 +0,0 @@
-#
-# 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
-  module TaskStatusMixin
-    def task_status_aux(mode, object_id, object_type, opts = {})
-      case mode
-        when :refresh
-          TaskStatus::RefreshMode.new(self, mode, object_id, object_type).task_status(opts)
-        when :snapshot 
-          TaskStatus::SnapshotMode.new(self, mode, object_id, object_type).task_status(opts)
-        when :stream  
-          assembly_or_workspace_id = object_id
-          task_status_stream(assembly_or_workspace_id)
-        else
-          legal_modes = [:refresh, :snapshot, :stream]
-          raise DtkError::Usage.new("Illegal mode '#{mode}'; legal modes are: #{legal_modes.join(', ')}")
-      end
-    end
-
-    def task_status_stream(assembly_or_workspace_id, opts = {})
-      TaskStatus::StreamMode.new(self, :stream, assembly_or_workspace_id, :assembly).get_and_render(opts)
-    end
-
-    def list_task_info_aux(object_type, object_id)
-      response = TaskStatus.new(self, object_id, object_type).post_call(:form => :list)
-      unless response.ok?
-        DtkError.raise_error(response)
-      end
-      response.override_command_class("list_task")
-      puts response.render_data
-    end
-  end
-
-  dtk_require_common_commands('thor/base_command_helper')
-  class TaskStatus < BaseCommandHelper
-    require File.expand_path('task_status/snapshot_mode', File.dirname(__FILE__))
-    require File.expand_path('task_status/refresh_mode', File.dirname(__FILE__))
-    require File.expand_path('task_status/stream_mode', File.dirname(__FILE__))
-
-    def initialize(command, mode, object_id, object_type)
-      super(command)
-      @mode        = mode
-      @object_id   = object_id
-      @object_type = object_type
-    end
-
-    private
-
-    def post_body(opts = {})
-      id_field = "#{@object_type}_id".to_sym
-      PostBody.new(
-        id_field                => @object_id,
-        :form?                  => opts[:form],
-        :wait_for?              => opts[:wait_for],
-        :summarize_node_groups? => opts[:summarize]
-     )
-    end
-
-    def post_call(opts={})
-      response = post rest_url("#{@object_type}/task_status"), post_body(opts)
-      unless response.ok?
-        DtkError.raise_error(response)
-      end
-      response
-    end
-
-  end
-end

data/lib/util/console.rb

@@ -1,235 +0,0 @@
-#
-# 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.
-#
-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
-
-      #
-      # Display confirmation prompt and repeat message until expected answer is given
-      #
-      def confirmation_prompt_simple(message, add_options=true)
-        # used to disable skip with ctrl+c
-        trap("INT", "SIG_IGN")
-        message += " (Y/n)" if add_options
-
-        while line = Readline.readline("#{message}: ", true)
-          if (line.downcase.eql?("yes") || line.downcase.eql?("y") || line.empty?)
-            trap("INT",false)
-            return true
-          elsif (line.downcase.eql?("no") || line.downcase.eql?("n"))
-            trap("INT",false)
-            return false
-          end
-        end
-      end
-
-      #
-      # Display confirmation prompt and repeat message until expected answer is given
-      # options should be sent as array ['all', 'none']
-      def confirmation_prompt_additional_options(message, options = [])
-        raise DTK::Client::DtkValidationError, "Options should be sent as array: ['all', 'none']" unless options.is_a?(Array)
-
-        # used to disable skip with ctrl+c
-        trap("INT", "SIG_IGN")
-        message += " (yes/no#{options.empty? ? '' : ('/' + options.join('/'))})"
-
-        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
-          elsif options.include?(line)
-            trap("INT",false)
-            return line
-          end
-        end
-      end
-
-      # multiple choice
-      # e.g.
-      # Select version to delete:
-      # 1. base
-      # 2. 0.0.1
-      # 3. 0.0.2
-      # 4. all
-      # > 2
-      def confirmation_prompt_multiple_choice(message, opts_array)
-        indexes = opts_array.map{ |opt| "#{opts_array.index(opt)+1}" }
-
-        trap("INT", "SIG_IGN")
-
-        message << "\n"
-        opts_array.each {|opt| message << "#{opts_array.index(opt)+1}. #{opt}\n" }
-        message << "> "
-
-        while line = Readline.readline("#{message}", true)
-          if indexes.include?(line)
-            trap("INT",false)
-            return opts_array[line.to_i-1]
-          elsif line.eql?('exit')
-            return nil
-          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)
-          prompt = DTK::Client::OsUtil.colorize("$:", :yellow)
-
-          Readline.completion_append_character = ""
-          Readline.completion_proc = Proc.new do |str|
-            Dir[str+'*'].grep(/^#{Regexp.escape(str)}/)
-          end
-          while line = Readline.readline("#{prompt}#{OsUtil.current_dir}>", 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
-                # we are sending stderr to stdout
-                system("#{line} 2>&1")
-              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