dtk-client 0.9.1 → 0.10.0

data/lib/{task_status → client/operation/service/task_status}/stream_mode.rb

@@ -17,21 +17,17 @@
 #
 require 'hirb'
 module DTK::Client
-  class TaskStatus
+  class Operation::Service::TaskStatus
     class StreamMode < self
-      require File.expand_path('stream_mode/element', File.dirname(__FILE__))
+      require_relative('stream_mode/element')
 
       def get_and_render(opts = {})
         Element.get_and_render_task_start(self, opts)
         Element.get_and_render_stages(self, {:wait => WaitWhenNoResults}.merge(opts))
-        Response::Ok.new()
+        return
       end
 
-      WaitWhenNoResults = 5 #in seconds
-      # making this public for this class and its children
-      def post_call(*args)
-        super
-      end
+      WaitWhenNoResults = 5
 
       private
       
@@ -39,7 +35,7 @@ module DTK::Client
       #    start_index: START_INDEX
       #    end_index: END_INDEX
       # convention is start_position = 0 and end_position = 0 means top level task with start time 
-      def post_body(opts = {})
+      def self.query_string_hash(opts = {})
         ret = super(opts)
         ret.merge(:start_index => opts[:start_index], :end_index => opts[:end_index])
       end

data/lib/client/operation/service/task_status.rb

@@ -0,0 +1,77 @@
+#
+# 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::Service
+    class TaskStatus < self
+      require_relative('task_status/snapshot_mode')
+      require_relative('task_status/refresh_mode')
+      require_relative('task_status/stream_mode')
+
+      def initialize(mode, service_instance)
+        @mode             = mode
+        @service_instance = service_instance
+      end
+
+      def self.execute(args = Args.new)
+        wrap_operation(args) do |args|
+          service_instance = args.required(:service_instance)
+          task_status_mode = args[:mode]
+          
+          if task_status_mode
+            task_status_with_mode(task_status_mode.to_sym, service_instance)
+          else
+            rest_call(service_instance).set_render_as_table!
+          end
+        end
+      end
+
+      def rest_call(opts = {})
+        self.class.rest_call(@service_instance, opts)
+      end
+      
+      private
+
+      LEGAL_MODES = [:refresh, :snapshot, :stream]
+      def self.task_status_with_mode(mode, service_instance, opts = {})
+        case mode
+        when :refresh
+          RefreshMode.new(mode, service_instance).task_status(opts)
+        when :snapshot 
+          SnapshotMode.new(mode, service_instance).task_status(opts)
+        when :stream
+          StreamMode.new(mode, service_instance).get_and_render(opts)
+        else
+          raise Error::Usage.new("Illegal mode '#{mode}'; legal modes are: #{LEGAL_MODES.join(', ')}")
+        end
+      end
+      
+      def self.rest_call(service_instance, opts = {})
+        rest_get("#{BaseRoute}/#{service_instance}/task_status", query_string_hash(opts))
+      end
+
+      def self.query_string_hash(opts = {})
+        QueryStringHash.new( 
+          :form?                  => opts[:form],
+          :wait_for?              => opts[:wait_for],
+          :summarize_node_groups? => opts[:summarize]
+        )
+      end
+      
+    end
+  end
+end

data/lib/client/operation/service.rb

@@ -0,0 +1,54 @@
+#
+# 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
+    class Service < self
+      OPERATIONS = [
+        :commit_and_push,
+        :destroy,
+        :edit,
+        :pull,
+        :stage,
+        :converge,
+        :task_status,
+        :list,
+        :list_actions,
+        :list_attributes,
+        :list_component_links,
+        :list_dependent_modules,
+        :list_components,
+        :list_nodes,
+        :list_violations,
+        :start,
+        :stop,
+        :cancel_task,
+        :ssh,
+        :set_required_attributes,
+        :exec,
+        :set_default_target
+        # :create_workspace
+      ]
+      OPERATIONS.each { |operation| require_relative("service/#{operation}") }
+
+      BaseRoute = 'services'
+
+      extend ModuleServiceCommon::ClassMixin
+
+    end
+  end
+end

data/lib/client/operation.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
+  # Abstract class that holds classes and methods for xecuting commands by
+  # make calls to server and performing client side operations
+  class Operation
+
+    require_relative('operation/module_service_common')
+
+    TYPES = [:account, :module, :service, :client_module_dir]
+    TYPES.each { |op_type| require_relative("operation/#{op_type}") }
+      
+    private
+    
+    # delegate rest calls to Session
+    def self.rest_post(route, post_body = {})
+      raise_error_if_notok_response do
+        Session.rest_post(route, post_body)
+      end
+    end
+    def rest_post(route, post_body = {})
+      self.class.rest_post(route, post_body)
+    end
+
+    def self.rest_get(route, query_string_hash = {})
+      raise_error_if_notok_response do
+        Session.rest_get(route, query_string_hash)
+      end
+    end
+    def rest_get(route, query_string_hash = {})
+      self.class.rest_get(route, query_string_hash)
+    end
+
+    def self.wrap_operation(args = Args.new, &block)
+      Response.wrap_as_response do
+        block.call(Args.convert(args))
+      end
+    end
+
+    # This is used so can fail on not ok rest responses without needing to do explicit
+    # response.ok? checks in many places
+    def self.raise_error_if_notok_response(&block)
+      response = block.call
+      if response.ok?
+        response
+      else
+        raise Error::ServerNotOkResponse.new(response)
+      end
+    end
+  end
+end
+

data/lib/client/operation_args.rb

@@ -0,0 +1,40 @@
+#
+# 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
+    class Args < ::Hash
+      def initialize(hash = {})
+        replace(hash)
+      end
+
+      def self.convert(ruby_hash_or_args)
+        ruby_hash_or_args.kind_of?(Args) ? ruby_hash_or_args : new(ruby_hash_or_args)
+      end
+
+      def required(key)
+        if has_key?(key)
+          self[key]
+        else
+          raise Error, "Args object missing the key '#{key}'"
+        end
+      end
+    end
+  end
+end
+
+

data/lib/{execute/execute_context/result_store.rb → client/render/view/simple.rb}

@@ -15,23 +15,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-class DTK::Client::Execute
-  class ExecuteContext
-    class ResultStore < Hash
-      def store(result,result_index=nil)
-        self[result_index||Index.last] = result
-      end
 
-      def get_last_result?()
-        self[Index.last]
-      end
-      
-      module Index
-        def self.last()
-          Last
+require 'yaml'
+module DTK::Client
+  class Render
+    class Simple < self
+
+      def render(data, _opts = {})
+        if data.kind_of?(Hash) or data.kind_of?(Array)
+          render_text(::DTK::DSL::YamlHelper.generate(data)) unless data.empty?
         end
-        Last = :last
       end
+
+      private
+
+      def initialize(render_type, _opts = {})
+        super(render_type)
+      end
+
     end
   end
 end

data/lib/client/render/view/table/processor.rb

@@ -0,0 +1,248 @@
+#
+# 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 'hirb'
+require 'ostruct'
+require 'colorize'
+require 'rest_client'
+require 'json'
+
+# we override String here to give power to our mutators defined in TableDefintions
+class String
+  def get_date
+    DateTime.parse(self).strftime('%H:%M:%S %d/%m/%y') unless self.nil?
+  end
+end
+
+module DTK::Client
+  class Render::Table
+    class Processor
+      include Hirb::Console
+
+      # opts can have keys
+      #  :print_error_table - Boolean (default: false)
+      def self.render(data, table_definition, opts = {})
+        new(table_definition).render(data, opts)
+      end
+
+      def initialize(table_definition)
+        @order_definition = table_definition.order_definition
+        @table_mapping    = table_definition.mapping
+        @evaluated_data = []
+        @error_data     = []
+        @action_data    = []
+      end
+      private :initialize
+
+
+      def render(data, opts = {})
+        evaluate(data, opts)
+        print
+      end
+
+      private
+
+      def evaluate(data, opts = {})
+        # very important since rest of the code expect array to be used
+        data = [data] unless data.kind_of?(Array)
+
+        print_error_table = opts[:print_error_table]
+
+
+        data.each do |data_element|
+          next if data_element['dtk_client_hidden']
+          structured_element = to_ostruct(data_element)
+        
+          # we use array of OpenStruct to hold our evaluated values
+          evaluated_element = OpenStruct.new
+          error_element     = OpenStruct.new
+          
+          # based on mapping we set key = eval(value)
+          @table_mapping.each do |k, v|
+            begin
+              if print_error_table && k.include?('error')
+                error_message = value_of(structured_element, v)
+
+                # due to problems with space we have special way of handling error columns
+                # in such a way that those error will be specially printed later on
+                server_error = nil
+              
+                # here we see if there was an error if not we will skip this
+                # if so we add it to @error_data
+                if error_message.empty?
+                  # no error message just add it as regular element
+                  evaluated_element.send("#{k}=",value_of(structured_element, v))
+                else
+                  error_index = ""
+                  error_type = value_of(structured_element,'errors.dtk_type') || ""
+          
+                  val = value_of(structured_element,'dtk_type')||''
+                  # extract e.g. 3.1.1.1 from '3.1.1.1 action' etc.
+                  error_index = "[ #{val.scan( /\d+[,.]?\d?[,.]?\d?[,.]?\d?[,.]?\d?/ ).first} ]"
+                  
+                  # original table takes that index
+                  evaluated_element.send("#{k}=", error_index)
+                  # we set new error element
+                  set_error_element!(error_element)
+                  
+                  # add it with other
+                  @error_data << error_element
+                end
+              else
+                evaluated_element.send("#{k}=", value_of(structured_element, v))
+                # eval "evaluated_element.#{k}=structured_element.#{v}"
+              end
+            rescue NoMethodError => e
+              unless e.message.include? "nil:NilClass"
+                # when chaining comands there are situations where more complex strcture
+                # e.g. external_ref.region will not be there. So we are handling that case
+                # make sure when in development to disable this TODO: better solution needed
+                raise Error, "Error with missing metadata occurred. There is a mistake in table metadata or unexpected data presented to table view."
+              end
+            end
+          end
+          
+          @order_definition.delete('errors')
+          
+          @evaluated_data << evaluated_element
+        end
+      end
+      
+      def set_error_element!(error_element)
+        error_element.id = error_index
+        case error_type
+        when 'user_error'
+          error_element.message = "[USER ERROR] #{error_message}"
+        when "test_error"
+          error_element.message = "[TEST ERROR] #{error_message}"
+        else
+          error_element.message = "[SERVER ERROR] #{error_message}"
+        end
+      end
+      
+      def print
+        filter_remove_underscore = Proc.new { |header| header.gsub('_',' ').upcase }
+        # hirb print out of our evaluated data in order defined
+        # Available options can be viewed here: http://tagaholic.me/hirb/doc/classes/Hirb/Helpers/Table.html#M000008
+        table(@evaluated_data,{:fields => @order_definition,:escape_special_chars => true, :resize => false, :vertical => false, :header_filter => filter_remove_underscore })
+        
+        # in case there were error we print those errors
+        unless @error_data.empty?
+          printf "\nERRORS: \n\n"
+          @error_data.each do |error_row|
+            printf "%15s %s\n", error_row.id.colorize(:yellow), error_row.message.colorize(:red)
+          end
+        end
+        
+        unless @action_data.empty?
+          printf " \n"
+          #table(@error_data,{:fields => [ :id, :message ]})
+          printed = []
+          @action_data.each do |action_row|
+            message = action_row.message
+            printf "%15s %s\n", "INFO:".colorize(:yellow), message.colorize(:yellow) unless printed.include?(message)
+            printed << message
+          end
+        end
+      end
+      
+      
+      def to_ostruct(data)
+        result = data.inject({}) do |res, (k, v)|
+          k = safe_name(k)
+          case v
+          when Hash
+            res.store(k, to_ostruct(v))
+            res
+          when Array
+            res.store(k, v.each { |el| Hash === el ? to_ostruct(el) : el })
+            res
+          else
+            res.store(k,v)
+            res
+          end
+        end
+        
+        OpenStruct.new(result)
+      end
+      
+      def safe_name(identifier)
+        (identifier == 'id' || identifier  == 'type') ? "dtk_#{identifier}" : identifier
+      end
+      
+      def filter_remove_underscore(_field)
+        nil
+      end
+      
+      # based on string sequence in mapped_command we are executing list of commands to follow
+      # so for value of "foo.bar.split('.').last" we will get 4 commands that will
+      # sequentaly be executed using values from previus results
+      def value_of(open_struct_object, mapped_command)
+        # split string by '.' delimiter keeping in mind to split when words only
+        commands = mapped_command.split(/\.(?=\w)/)
+        
+        value = open_struct_object
+        commands.each do |command|
+          value = evaluate_command(value, command)
+        end
+        value
+      end
+      
+      def evaluate_command(value, command)
+        case
+        when command.include?('map{')
+          matched_data = command.match(/\['(.+)'\]/)
+          
+          my_lambda = lambda{|_x| _x.map{|r|r["#{matched_data[1]}"]||[]}}
+          value = my_lambda.call(value)
+          
+          raise Error, "There is a mistake in table metadata: #{command.inspect}" if value.nil?
+        when command.include?('(')
+          # matches command and params e.g. split('.') => [1] split, [2] '.'
+          matched_data = command.match(/(.+)\((.+)\)/)
+          command, params = matched_data[1], matched_data[2]
+          value = value.send(command,params)
+        when command.include?('[')
+          # matches command such as first['foo']
+          matched_data    = command.match(/(.+)\[(.+)\]/)
+          command, params =  matched_data[1],matched_data[2]
+          
+          value = evaluate_command(value,command)
+          value = value.send('[]',params)
+        when command.start_with?("list_")
+          matched_data = command.match(/list_(.+)/)
+          
+          my_lambda = lambda{|_x| _x.map{|r|r["#{matched_data[1]}"]||[]}}
+          value = my_lambda.call(value)
+          
+          raise Error, "There is a mistake in table metadata: #{command.inspect}" if value.nil?
+        when command.start_with?("count_")
+          matched_data = command.match(/count_(.+)/)
+          
+          my_lambda = lambda{|_x| _x.map{|r|r["#{matched_data[1]}"]||[]}.flatten.size}
+          value = my_lambda.call(value)
+          
+          raise Error, "There is a mistake in table metadata: #{command.inspect}" if value.nil?
+        else
+          value = value.send(command)
+        end
+        value
+      end
+    end
+  end
+end
+

data/lib/client/render/view/table.rb

@@ -0,0 +1,75 @@
+#
+# 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 Render
+    class Table < self 
+      require_relative('table/processor')
+
+      # opts can have keys
+      #  :semantic_datatype (required)
+      def initialize(render_type, opts = {})
+        unless semantic_datatype = opts[:semantic_datatype]
+          raise Error, 'Missing opts[:semantic_datatype] value'
+        end
+        super(render_type, semantic_datatype)
+        @table_definition = get_table_definition?(semantic_datatype)
+      end
+
+      # opts can have keys
+      #   :print_error_table - Boolean (default: false)
+      #   :table_definition - if set overrides the one associated with the object
+      def render(data, opts = {})
+        unless table_definition = opts[:table_definition] || @table_definition
+          raise Error, 'Missing table definition'
+        end
+        if data.empty?
+          render_text("Table is empty\n")
+        else
+          Processor.render(data, table_definition, opts)
+        end
+      end
+
+      private
+      
+      TableDefinition = Struct.new(:mapping, :order_definition)
+      def get_table_definition?(semantic_datatype)
+        if table_def_hash = (table_definitions || {})[table_def_index_from_semantic_datatype(semantic_datatype)]
+          TableDefinition.new(table_def_hash['mapping'], table_def_hash['order'])
+        end
+      end
+
+      def table_def_index_from_semantic_datatype(semantic_datatype)
+        semantic_datatype.to_s
+      end
+
+      def table_definitions
+        # TODO: put back in caching after take into account :meta_table_ttl
+        # @@table_definitions_metadata ||= get_table_definitions_metadata 
+        get_table_definitions
+      end
+
+      # get all table definitions from json file
+      def get_table_definitions
+        content = DiskCacher.new.fetch('table_metadata', Config[:meta_table_ttl])
+        raise Error, 'Table metadata is empty' if content.empty?
+        JSON.parse(content)
+      end
+    end
+  end
+end