karafka-web 0.7.10 → 0.8.0.rc1

data/lib/karafka/web/ui/app.rb

@@ -48,9 +48,18 @@ module Karafka
             end
           end
 
-          r.get 'jobs' do
+          r.on 'jobs' do
             controller = Controllers::Jobs.new(params)
-            controller.index
+
+            r.get 'running' do
+              controller.running
+            end
+
+            r.get 'pending' do
+              controller.pending
+            end
+
+            r.redirect root_path('jobs/running')
           end
 
           r.on 'routing' do
@@ -65,9 +74,18 @@ module Karafka
             end
           end
 
-          r.get 'cluster' do
+          r.on 'cluster' do
             controller = Controllers::Cluster.new(params)
-            controller.index
+
+            r.get 'brokers' do
+              controller.brokers
+            end
+
+            r.get 'topics' do
+              controller.topics
+            end
+
+            r.redirect root_path('cluster/brokers')
           end
 
           r.on 'errors' do

data/lib/karafka/web/ui/base.rb

@@ -55,10 +55,16 @@ module Karafka
 
         plugin :custom_block_results
 
-        handle_block_result Controllers::Responses::Data do |result|
+        handle_block_result Controllers::Responses::Render do |result|
           render_response(result)
         end
 
+        handle_block_result Controllers::Responses::Deny do
+          @error = true
+          response.status = 403
+          view 'shared/exceptions/not_allowed'
+        end
+
         # Redirect either to referer back or to the desired path
         handle_block_result Controllers::Responses::Redirect do |result|
           # Map redirect flashes (if any) to Roda flash messages
@@ -67,6 +73,12 @@ module Karafka
           response.redirect result.back? ? request.referer : root_path(result.path)
         end
 
+        handle_block_result Controllers::Responses::File do |result|
+          response.headers['Content-Type'] = 'application/octet-stream'
+          response.headers['Content-Disposition'] = "attachment; filename=\"#{result.file_name}\""
+          response.write result.content
+        end
+
         # Display appropriate error specific to a given error type
         plugin :error_handler, classes: [
           ::Rdkafka::RdkafkaError,
@@ -111,10 +123,14 @@ module Karafka
           raise Errors::Ui::NotFoundError
         end
 
-        # Allows us to build current path with additional params
+        # Allows us to build current path with additional params + it merges existing params into
+        # the query data. Query data takes priority over request params.
         # @param query_data [Hash] query params we want to add to the current path
         path :current do |query_data = {}|
           q = query_data
+              .transform_values(&:to_s)
+              .transform_keys(&:to_s)
+              .then { |candidates| request.params.merge(candidates) }
               .select { |_, v| v }
               .map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }
               .join('&')

data/lib/karafka/web/ui/controllers/base.rb

@@ -7,6 +7,13 @@ module Karafka
       module Controllers
         # Base controller from which all the controllers should inherit.
         class Base
+          class << self
+            # Attributes on which we can sort in a given controller
+            attr_accessor :sortable_attributes
+          end
+
+          self.sortable_attributes = []
+
           # @param params [Karafka::Web::Ui::Controllers::Requests::Params] request parameters
           def initialize(params)
             @params = params
@@ -14,10 +21,10 @@ module Karafka
 
           private
 
-          # Builds the respond data object with assigned attributes based on instance variables.
+          # Builds the render data object with assigned attributes based on instance variables.
           #
-          # @return [Responses::Data] data that should be used to render appropriate view
-          def respond
+          # @return [Responses::Render] data that should be used to render appropriate view
+          def render
             attributes = {}
 
             scope = self.class.to_s.split('::').last.gsub(/(.)([A-Z])/, '\1_\2').downcase
@@ -30,7 +37,7 @@ module Karafka
               attributes[iv.to_s.delete('@').to_sym] = instance_variable_get(iv)
             end
 
-            Responses::Data.new(
+            Responses::Render.new(
               "#{scope}/#{action}",
               attributes
             )
@@ -45,6 +52,29 @@ module Karafka
             Responses::Redirect.new(path, flashes)
           end
 
+          # Builds a file response object that will be used as a base to dispatch the file
+          #
+          # @param content [String] Payload we want to dispatch as a file
+          # @param file_name [String] name under which the browser is suppose to save the file
+          # @return [Responses::File] file response result
+          def file(content, file_name)
+            Responses::File.new(content, file_name)
+          end
+
+          # Builds a halt 403 response
+          def deny
+            Responses::Deny.new
+          end
+
+          # @param resources [Hash, Array, Lib::HashProxy] object for sorting
+          # @return [Hash, Array, Lib::HashProxy] sorted results
+          def refine(resources)
+            Lib::Sorter.new(
+              @params.sort,
+              allowed_attributes: self.class.sortable_attributes
+            ).call(resources)
+          end
+
           # Initializes the expected pagination engine and assigns expected arguments
           # @param args Any arguments accepted by the selected pagination engine
           def paginate(*args)

data/lib/karafka/web/ui/controllers/become_pro.rb

@@ -8,7 +8,7 @@ module Karafka
         class BecomePro < Base
           # Display a message, that a given feature is available only in Pro
           def show
-            respond
+            render
           end
         end
       end

data/lib/karafka/web/ui/controllers/cluster.rb

@@ -6,31 +6,55 @@ module Karafka
       module Controllers
         # Selects cluster info and topics basic info
         class Cluster < Base
-          # List cluster info data
-          def index
-            # Make sure, that for the cluster view we always get the most recent cluster state
-            @cluster_info = Models::ClusterInfo.fetch(cached: false)
+          self.sortable_attributes = %w[
+            broker_id
+            broker_name
+            broker_port
+            topic_name
+            partition_id
+            leader
+            replica_count
+            in_sync_replica_brokers
+          ].freeze
 
+          # Lists available brokers in the cluster
+          def brokers
+            @brokers = refine(cluster_info.brokers)
+
+            render
+          end
+
+          # List topics and partitions with details
+          def topics
             partitions_total = []
 
-            displayable_topics(@cluster_info).each do |topic|
+            displayable_topics(cluster_info).each do |topic|
               topic[:partitions].each do |partition|
-                partitions_total << partition.merge(topic: topic)
+                partitions_total << partition.merge(
+                  topic: topic,
+                  # Will allow sorting by name
+                  topic_name: topic.fetch(:topic_name)
+                )
               end
             end
 
             @partitions, last_page = Ui::Lib::Paginations::Paginators::Arrays.call(
-              partitions_total,
+              refine(partitions_total),
               @params.current_page
             )
 
             paginate(@params.current_page, !last_page)
 
-            respond
+            render
           end
 
           private
 
+          # Make sure, that for the cluster view we always get the most recent cluster state
+          def cluster_info
+            @cluster_info ||= Models::ClusterInfo.fetch(cached: false)
+          end
+
           # @param cluster_info [Rdkafka::Metadata] cluster metadata
           # @return [Array<Hash>] array with topics to be displayed sorted in an alphabetical
           #   order
@@ -39,7 +63,7 @@ module Karafka
                   .topics
                   .sort_by { |topic| topic[:topic_name] }
 
-            return all if ::Karafka::Web.config.ui.show_internal_topics
+            return all if ::Karafka::Web.config.ui.visibility.internal_topics
 
             all.reject { |topic| topic[:topic_name].start_with?('__') }
           end

data/lib/karafka/web/ui/controllers/consumers.rb

@@ -6,19 +6,25 @@ module Karafka
       module Controllers
         # Consumers (consuming processes - `karafka server`) processes display consumer
         class Consumers < Base
+          self.sortable_attributes = %w[
+            name
+            started_at
+            lag_stored
+          ].freeze
+
           # List page with consumers
           # @note For now we load all and paginate over the squashed data.
           def index
             @current_state = Models::ConsumersState.current!
             @counters = Models::Counters.new(@current_state)
             @processes, last_page = Ui::Lib::Paginations::Paginators::Arrays.call(
-              Models::Processes.active(@current_state),
+              refine(Models::Processes.active(@current_state)),
               @params.current_page
             )
 
             paginate(@params.current_page, !last_page)
 
-            respond
+            render
           end
         end
       end

data/lib/karafka/web/ui/controllers/dashboard.rb

@@ -20,10 +20,10 @@ module Karafka
 
             # Load only historicals for the selected range
             @aggregated_charts = Models::Metrics::Charts::Aggregated.new(
-              @aggregated, :seconds
+              @aggregated, @params.current_range
             )
 
-            respond
+            render
           end
         end
       end

data/lib/karafka/web/ui/controllers/errors.rb

@@ -20,7 +20,7 @@ module Karafka
               @error_messages.map(&:offset)
             )
 
-            respond
+            render
           end
 
           # @param offset [Integer] given error message offset
@@ -31,7 +31,7 @@ module Karafka
               offset
             )
 
-            respond
+            render
           end
 
           private

data/lib/karafka/web/ui/controllers/jobs.rb

@@ -6,27 +6,77 @@ module Karafka
       module Controllers
         # Active jobs (work) reporting controller
         class Jobs < Base
-          # Lists jobs
-          def index
+          self.sortable_attributes = %w[
+            name
+            topic
+            consumer
+            type
+            updated_at
+          ].freeze
+
+          # Lists running jobs
+          def running
             current_state = Models::ConsumersState.current!
             processes = Models::Processes.active(current_state)
 
+            @jobs_counters = count_jobs_types(processes)
+
             # Aggregate jobs and inject the process info into them for better reporting
             jobs_total = processes.flat_map do |process|
-              process.jobs.map do |job|
+              process.jobs.running.map do |job|
                 job.to_h[:process] = process
                 job
               end
             end
 
             @jobs, last_page = Ui::Lib::Paginations::Paginators::Arrays.call(
-              jobs_total,
+              refine(jobs_total),
               @params.current_page
             )
 
             paginate(@params.current_page, !last_page)
 
-            respond
+            render
+          end
+
+          # Lists pending jobs
+          def pending
+            current_state = Models::ConsumersState.current!
+            processes = Models::Processes.active(current_state)
+
+            @jobs_counters = count_jobs_types(processes)
+
+            # Aggregate jobs and inject the process info into them for better reporting
+            jobs_total = processes.flat_map do |process|
+              process.jobs.pending.map do |job|
+                job.to_h[:process] = process
+                job
+              end
+            end
+
+            @jobs, last_page = Ui::Lib::Paginations::Paginators::Arrays.call(
+              refine(jobs_total),
+              @params.current_page
+            )
+
+            paginate(@params.current_page, !last_page)
+
+            render
+          end
+
+          private
+
+          # @param processes [Array<Models::Process>]
+          # @return [Lib::HashProxy] particular type jobs count
+          def count_jobs_types(processes)
+            counts = { running: 0, pending: 0 }
+
+            processes.flat_map do |process|
+              counts[:running] += process.jobs.running.size
+              counts[:pending] += process.jobs.pending.size
+            end
+
+            Lib::HashProxy.new(counts)
           end
         end
       end

data/lib/karafka/web/ui/controllers/requests/params.rb

@@ -24,6 +24,11 @@ module Karafka
               @request_params = request_params
             end
 
+            # @return [String] sort query value
+            def sort
+              @sort ||= @request_params['sort'].to_s.downcase
+            end
+
             # @return [Integer] current page for paginated views
             # @note It does basic sanitization
             def current_page

data/lib/karafka/web/ui/controllers/responses/deny.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Web
+    module Ui
+      module Controllers
+        module Responses
+          # Response that will make Roda render 403 deny
+          class Deny
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/web/ui/controllers/responses/file.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Web
+    module Ui
+      module Controllers
+        module Responses
+          # Response that tells Roda to ship the content under a file name
+          class File
+            attr_reader :content, :file_name
+
+            # @param content [String] data we want to send
+            # @param file_name [String] name under which we want to send it
+            def initialize(content, file_name)
+              @content = content
+              @file_name = file_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/web/ui/controllers/responses/{data.rb → render.rb}

@@ -6,10 +6,10 @@ module Karafka
       module Controllers
         # Response related components
         module Responses
-          # Response data object. It is used to transfer attributes assigned in controllers into
-          # views
+          # Response render data object. It is used to transfer attributes assigned in controllers
+          # into views
           # It acts as a simplification / transport layer for assigned attributes
-          class Data
+          class Render
             attr_reader :path, :attributes
 
             # @param path [String] render path

data/lib/karafka/web/ui/controllers/routing.rb

@@ -6,11 +6,20 @@ module Karafka
       module Controllers
         # Routing presentation controller
         class Routing < Base
+          self.sortable_attributes = %w[
+            name
+            active?
+          ].freeze
+
           # Routing list
           def index
             @routes = Karafka::App.routes
 
-            respond
+            @routes.each do |consumer_group|
+              refine(consumer_group.topics)
+            end
+
+            render
           end
 
           # Given route details
@@ -21,7 +30,7 @@ module Karafka
 
             @topic || raise(::Karafka::Web::Errors::Ui::NotFoundError, topic_id)
 
-            respond
+            render
           end
         end
       end

data/lib/karafka/web/ui/controllers/status.rb

@@ -15,7 +15,7 @@ module Karafka
             @status = Models::Status.new
             @sampler = Tracking::Sampler.new
 
-            respond
+            render
           end
         end
       end

data/lib/karafka/web/ui/helpers/application_helper.rb

@@ -126,6 +126,40 @@ module Karafka
             %(<span title="#{stamp}">#{time}</span>)
           end
 
+          # @param state [String] poll state
+          # @param state_ch [Integer] time until next change of the poll state
+          #   (from paused to active)
+          # @return [String] span tag with label and title with change time if present
+          def poll_state_with_change_time_label(state, state_ch)
+            year_in_seconds = 131_556_926
+            state_ch_in_seconds = state_ch / 1_000.0
+
+            # If state is active, there is no date of change
+            if state == 'active'
+              %(
+                <span class="badge #{kafka_state_bg(state)} mt-1 mb-1">#{state}</span>
+              )
+            elsif state_ch_in_seconds > year_in_seconds
+              %(
+                <span
+                  class="badge #{kafka_state_bg(state)} mt-1 mb-1"
+                  title="until manual resume"
+                >
+                  #{state}
+                </span>
+              )
+            else
+              %(
+                <span
+                  class="badge #{kafka_state_bg(state)} time-title mt-1 mb-1"
+                  title="#{Time.now + state_ch_in_seconds}"
+                >
+                  #{state}
+                </span>
+              )
+            end
+          end
+
           # @param lag [Integer] lag
           # @return [String] lag if correct or `N/A` with labeled explanation
           # @see #offset_with_label
@@ -212,6 +246,42 @@ module Karafka
 
             result
           end
+
+          # @param name [String] link value
+          # @param attribute [Symbol, nil] sorting attribute or nil if we provide only symbol name
+          # @param rev [Boolean] when set to true, arrows will be in the reverse position. This is
+          #   used when the description in the link is reverse to data we sort. For example we have
+          #   order on when processes were started and we display "x hours" ago but we sort on
+          #   their age, meaning that it looks like it is the other way around. This flag allows
+          #   us to reverse just he arrow making it look consistent with the presented data order
+          # @return [String] html link for sorting with arrow when attribute sort enabled
+          def sort_link(name, attribute = nil, rev: false)
+            unless attribute
+              attribute = name
+              name = attribute.to_s.tr('_', ' ').capitalize
+            end
+
+            arrow_both = '&#x21D5;'
+            arrow_down = '&#9662;'
+            arrow_up = '&#9652;'
+
+            desc = "#{attribute} desc"
+            asc = "#{attribute} asc"
+            path = current_path(sort: desc)
+            full_name = "#{name}&nbsp;#{arrow_both}"
+
+            if params.sort == desc
+              path = current_path(sort: asc)
+              full_name = "#{name}&nbsp;#{rev ? arrow_up : arrow_down}"
+            end
+
+            if params.sort == asc
+              path = current_path(sort: desc)
+              full_name = "#{name}&nbsp;#{rev ? arrow_down : arrow_up}"
+            end
+
+            "<a class=\"sort\" href=\"#{path}\">#{full_name}</a>"
+          end
         end
       end
     end

data/lib/karafka/web/ui/lib/hash_proxy.rb

@@ -17,12 +17,17 @@ module Karafka
         class HashProxy
           extend Forwardable
 
-          def_delegators :@hash, :[], :[]=, :key?, :each, :find
+          def_delegators :@hash, :[], :[]=, :key?, :each, :find, :values, :keys, :select
 
           # @param hash [Hash] hash we want to convert to a proxy
           def initialize(hash)
             @hash = hash
-            @visited = []
+            # Nodes we already visited in the context of a given attribute lookup
+            # We cache them not to look for them over and over again if they are used more than
+            # once
+            @visited = Hash.new { |h, k| h[k] = {} }
+            # Methods invocations cache
+            @results = {}
           end
 
           # @return [Original hash]
@@ -34,22 +39,32 @@ module Karafka
           # @param args [Object] all the args of the method
           # @param block [Proc] block for the method
           def method_missing(method_name, *args, &block)
-            return super unless args.empty? && block.nil?
+            method_name = method_name.to_sym
 
-            @visited.clear
+            return super unless args.empty? && block.nil?
+            return @results[method_name] if @results.key?(method_name)
 
-            result = deep_find(@hash, method_name.to_sym)
+            result = deep_find(@hash, method_name)
 
-            @visited.clear
+            return super if result.nil?
 
-            result.nil? ? super : result
+            @results[method_name] = result
           end
 
           # @param method_name [String] method name
           # @param include_private [Boolean]
           def respond_to_missing?(method_name, include_private = false)
-            result = deep_find(@hash, method_name.to_sym)
-            result.nil? ? super : true
+            method_name = method_name.to_sym
+
+            return true if @results.key?(method_name)
+
+            result = deep_find(@hash, method_name)
+
+            return super if result.nil?
+
+            @results[method_name] = result
+
+            true
           end
 
           private
@@ -59,16 +74,16 @@ module Karafka
           def deep_find(obj, key)
             # Prevent circular dependency lookups by making sure we do not check the same object
             # multiple times
-            return nil if @visited.include?(obj)
+            return nil if @visited[key].key?(obj)
 
-            @visited << obj
+            @visited[key][obj] = nil
 
             if obj.respond_to?(:key?) && obj.key?(key)
               obj[key]
             elsif obj.respond_to?(:each)
-              r = nil
-              obj.find { |*a| r = deep_find(a.last, key) }
-              r
+              result = nil
+              obj.find { |*a| result = deep_find(a.last, key) }
+              result
             end
           end
         end