ruby-grafana-reporter 0.1.6 → 0.3.0

data/lib/grafana_reporter/application/errors.rb

@@ -1,30 +1,33 @@
-module GrafanaReporter
-  module Application
-    # General grafana application error, from which the specific errors
-    # inherit.
-    class ApplicationError < GrafanaReporterError
-    end
-
-    # Thrown if a non existing template has been specified.
-    class MissingTemplateError < ApplicationError
-      def initialize(template)
-        super("Given report template '#{template}' is not a valid template.")
-      end
-    end
-
-    # Thrown, if a webservice request has been requested, which could not be
-    # handled.
-    class WebserviceUnknownPathError < ApplicationError
-      def initialize(request)
-        super("Request '#{request}' calls an unknown path for this webservice.")
-      end
-    end
-
-    # Thrown, if an internal error appeared during creation of the report.
-    class WebserviceGeneralRenderingError < ApplicationError
-      def initialize(error)
-        super("Could not render report because of internal error: #{error}")
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Application
+    # General grafana application error, from which the specific errors
+    # inherit.
+    class ApplicationError < GrafanaReporterError
+    end
+
+    # Thrown, if the '-s' parameter is not configured with exactly one variable
+    # name and one value.
+    class ParameterValueError < ApplicationError
+      def initialize(length)
+        super("Parameter '-s' needs exactly two values separated by comma, received #{length}.")
+      end
+    end
+
+    # Thrown, if a webservice request has been requested, which could not be
+    # handled.
+    class WebserviceUnknownPathError < ApplicationError
+      def initialize(request)
+        super("Request '#{request}' calls an unknown path for this webservice.")
+      end
+    end
+
+    # Thrown, if an internal error appeared during creation of the report.
+    class WebserviceGeneralRenderingError < ApplicationError
+      def initialize(error)
+        super("Could not render report because of internal error: #{error}")
+      end
+    end
+  end
+end

data/lib/grafana_reporter/application/webservice.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Application
+    # This class provides the webservice for the reporter application. It does not
+    # make use of `webrick` or similar, so that it can be used without futher dependencies
+    # in conjunction with the standard asciidoctor docker container.
+    class Webservice
+      def initialize(config)
+        @reports = []
+        @config = config
+        @logger = config.logger
+      end
+
+      # Runs the webservice with the current set {Configuration} object.
+      def run
+        # start webserver
+        @server = TCPServer.new(@config.webserver_port)
+        @logger.info("Server listening on port #{@config.webserver_port}...")
+
+        @progress_reporter = Thread.new {}
+
+        accept_requests_loop
+      end
+
+      private
+
+      def accept_requests_loop
+        loop do
+          # step 1) accept incoming connection
+          socket = @server.accept
+
+          # step 2) print the request headers (separated by a blank line e.g. \r\n)
+          request = ''
+          line = ''
+          begin
+            until line == "\r\n"
+              line = socket.readline
+              request += line
+            end
+          rescue EOFError => e
+            @logger.debug("Webserver EOFError: #{e.message}")
+          end
+
+          begin
+            response = handle_request(request)
+            socket.write response
+          rescue WebserviceUnknownPathError => e
+            @logger.debug(e.message)
+            socket.write http_response(404, '', e.message)
+          rescue MissingTemplateError => e
+            @logger.error(e.message)
+            socket.write http_response(400, 'Bad Request', e.message)
+          rescue WebserviceGeneralRenderingError => e
+            @logger.fatal(e.message)
+            socket.write http_response(400, 'Bad Request', e.message)
+          rescue StandardError => e
+            @logger.fatal(e.message)
+            socket.write http_response(400, 'Bad Request', e.message)
+          ensure
+            socket.close
+          end
+
+          log_report_progress
+          clean_outdated_temporary_reports
+        end
+      end
+
+      def log_report_progress
+        return if @progress_reporter.alive?
+
+        @progress_reporter = Thread.new do
+          running_reports = @reports.reject(&:done)
+          until running_reports.empty?
+            unless running_reports.empty?
+              @logger.info("#{running_reports.length} report(s) in progress: "\
+                           "#{running_reports.map do |report|
+                                "#{(report.progress * 100).to_i}% (running #{report.execution_time.to_i} secs)"
+                              end.join(', ')}")
+            end
+            sleep 5
+            running_reports = @reports.reject(&:done)
+          end
+          # puts "no more running reports - stopping to report progress"
+        end
+      end
+
+      def clean_outdated_temporary_reports
+        clean_time = Time.now - 60 * 60 * @config.report_retention
+        @reports.select { |report| report.done && clean_time > report.end_time }.each do |report|
+          @reports.delete(report).delete_file
+        end
+      end
+
+      def handle_request(request)
+        raise WebserviceUnknownPathError, request.split("\r\n")[0] if request.nil?
+        raise WebserviceUnknownPathError, request.split("\r\n")[0] if request.split("\r\n")[0].nil?
+
+        query_string = request.split("\r\n")[0].gsub(%r{(?:[^?]+\?)(.*)(?: HTTP/.*)$}, '\1')
+        query_parameters = CGI.parse(query_string)
+
+        @logger.debug("Received request: #{request.split("\r\n")[0]}")
+        @logger.debug("query_parameters: #{query_parameters}")
+
+        # read URL parameters
+        attrs = {}
+        query_parameters.each do |k, v|
+          attrs[k] = v.length == 1 ? v[0] : v
+        end
+
+        case request.split("\r\n")[0]
+        when %r{^GET /render[? ]}
+          return render_report(attrs)
+
+        when %r{^GET /overview[? ]}
+          # show overview for current reports
+          return get_reports_status_as_html(@reports)
+
+        when %r{^GET /view_report[? ]}
+          return view_report(attrs)
+
+        when %r{^GET /cancel_report[? ]}
+          return cancel_report(attrs)
+
+        when %r{^GET /view_log[? ]}
+          return view_log(attrs)
+        end
+
+        raise WebserviceUnknownPathError, request.split("\r\n")[0]
+      end
+
+      def view_log(attrs)
+        # view report if already available, or show status view
+        report = @reports.select { |r| r.object_id.to_s == attrs['report_id'].to_s }.first
+        raise WebserviceGeneralRenderingError, 'view_log has been called without valid id' if report.nil?
+
+        content = report.full_log
+
+        http_response(200, 'OK', content, "Content-Type": 'text/plain')
+      end
+
+      def cancel_report(attrs)
+        # view report if already available, or show status view
+        report = @reports.select { |r| r.object_id.to_s == attrs['report_id'].to_s }.first
+        raise WebserviceGeneralRenderingError, 'cancel_report has been called without valid id' if report.nil?
+
+        report.cancel! unless report.done
+
+        # redirect to view_report page
+        http_response(302, 'Found', nil, Location: "/view_report?report_id=#{report.object_id}")
+      end
+
+      def view_report(attrs)
+        # view report if already available, or show status view
+        report = @reports.select { |r| r.object_id.to_s == attrs['report_id'].to_s }.first
+        raise WebserviceGeneralRenderingError, 'view_report has been called without valid id' if report.nil?
+
+        # show report status
+        return get_reports_status_as_html([report]) if !report.done || !report.error.empty?
+
+        # provide report
+        @logger.debug("Returning PDF report at #{report.path}")
+        content = File.read(report.path, mode: 'rb')
+        return http_response(200, 'OK', content, "Content-Type": 'application/pdf') if content.start_with?('%PDF')
+
+        http_response(200, 'OK', content, "Content-Type": 'application/octet-stream',
+                                          "Content-Disposition": "attachment; filename=report_#{attrs['report_id']}.zip")
+      end
+
+      def render_report(attrs)
+        # build report
+        template_file = "#{@config.templates_folder}#{attrs['var-template']}.adoc"
+
+        file = Tempfile.new('gf_pdf_', @config.reports_folder)
+        begin
+          FileUtils.chmod('+r', file.path)
+        rescue StandardError => e
+          @logger.debug("File permissions could not be set for #{file.path}: #{e.message}")
+        end
+
+        report = @config.report_class.new(@config, template_file, file, attrs)
+        Thread.new do
+          report.create_report
+        end
+        @reports << report
+
+        http_response(302, 'Found', nil, Location: "/view_report?report_id=#{report.object_id}")
+      end
+
+      def get_reports_status_as_html(reports)
+        i = reports.length
+
+        content = '<html>'\
+                  '<head></head>'\
+                  '<body>'\
+                  '<table>'\
+                  '<thead>'\
+                  '<th>#</th>'\
+                  '<th>Start Time</th>'\
+                  '<th>End Time</th>'\
+                  '<th>Template</th>'\
+                  '<th>Execution time</th>'\
+                  '<th>Status</th>'\
+                  '<th>Error</th>'\
+                  '<th>Action</th>'\
+                  '</thead>' +
+                  reports.reverse.map do |report|
+                    '<tr>'\
+                    "<td>#{i -= 1}</td>"\
+                    "<td>#{report.start_time}</td>"\
+                    "<td>#{report.end_time}</td>"\
+                    "<td>#{report.template}</td>"\
+                    "<td>#{report.execution_time.to_i} secs</td><td>#{report.status} (#{(report.progress * 100).to_i}%)</td><td>#{report.error.join('<br>')}</td>"\
+                    "<td>#{!report.done && !report.cancel ? "<a href=\"/cancel_report?report_id=#{report.object_id}\">Cancel</a>&nbsp;" : ''}"\
+                    "#{(report.status == 'finished') || (report.status == 'cancelled') ? "<a href=\"/view_report?report_id=#{report.object_id}\">View</a>&nbsp;" : '&nbsp;'}"\
+                    "<a href=\"/view_log?report_id=#{report.object_id}\">Log</a></td>"\
+                    '</tr>'
+                  end.join('') +
+                  '</table></body></html>'
+
+        http_response(200, 'OK', content, "Content-Type": 'text/html')
+      end
+
+      def http_response(code, text, body, opts = {})
+        "HTTP/1.1 #{code} #{text}\r\n#{opts.map { |k, v| "#{k}: #{v}" }.join("\r\n")}"\
+        "#{body ? "\r\nContent-Length: #{body.to_s.bytesize}" : ''}\r\n\r\n#{body}"
+      end
+    end
+  end
+end

data/lib/grafana_reporter/asciidoctor/alerts_table_query.rb

@@ -1,99 +1,101 @@
-require_relative 'query_mixin'
-
-module GrafanaReporter
-  module Asciidoctor
-    # This class is used to query alerts from grafana.
-    class AlertsTableQuery < Grafana::AbstractQuery
-      include QueryMixin
-
-      # @option opts [Grafana::Dashboard] :dashboard  dashboard, if alerts shall be filtered for a dashboard
-      # @option opts [Grafnaa::Oanel] :panel panel, if alerts shall be filtered for a panel
-      def initialize(opts = {})
-        super()
-
-        @dashboard = opts[:dashboard]
-        @panel = opts[:panel]
-        @dashboard = @panel.dashboard if @panel
-
-        extract_dashboard_variables(@dashboard) if @dashboard
-      end
-
-      # @return [String] URL for querying alerts
-      def url
-        '/api/alerts' + url_parameters
-      end
-
-      # @return [Hash] empty hash object
-      def request
-        {}
-      end
-
-      # Check if mandatory {Grafana::Variable} +columns+ is specified in variables.
-      #
-      # The value of the +columns+ variable has to be a comma separated list of column titles, which
-      # need to be included in the following list:
-      # - limit
-      # - dashboardId
-      # - panelId
-      # - query
-      # - state
-      # - folderId
-      # - dashboardQuery
-      # - dashboardTag
-      # @return [void]
-      def pre_process(_grafana)
-        raise MissingMandatoryAttributeError, 'columns' unless @variables['columns']
-
-        @from = translate_date(@from, @variables['grafana-report-timestamp'], false)
-        @to = translate_date(@to, @variables['grafana-report-timestamp'], true)
-      end
-
-      # Filter the query result for the given columns and sets the result in the preformatted SQL
-      # result stlye.
-
-      # Additionally it applies {QueryMixin#format_columns}, {QueryMixin#replace_values} and
-      # {QueryMixin#filter_columns}.
-      # @return [void]
-      def post_process
-        # extract data from returned json
-        result = JSON.parse(@result.body)
-        content = []
-        begin
-          result.each { |item| content << item.fetch_values(*@variables['columns'].raw_value.split(',')) }
-        rescue KeyError => e
-          raise MalformedAttributeContentError.new(e.message, 'columns', @variables['columns'])
-        end
-
-        result = {}
-        result[:header] = [@variables['columns'].raw_value.split(',')]
-        result[:content] = content
-
-        result = format_columns(result, @variables['format'])
-        result = replace_values(result, @variables.select { |k, _v| k =~ /^replace_values_\d+/ })
-        result = filter_columns(result, @variables['filter_columns'])
-        if @variables['filter_column']
-          @report.logger.warn("DEPRECATED: Call of  no longer supported function 'filter_column' has been found. Rename to 'filter_columns'")
-          result = filter_columns(result, @variables['filter_column'])
-        end
-
-        @result = result[:content].map { |row| '| ' + row.map { |item| item.to_s.gsub('|', '\\|') }.join(' | ') }
-      end
-
-      private
-
-      def url_parameters
-        url_vars = {}
-        url_vars['dashboardId'] = ::Grafana::Variable.new(@dashboard.id) if @dashboard
-        url_vars['panelId'] = ::Grafana::Variable.new(@panel.id) if @panel
-
-        url_vars.merge!(variables.select { |k, _v| k =~ /^(?:limit|dashboardId|panelId|query|state|folderId|dashboardQuery|dashboardTag)/ })
-        url_vars['from'] = ::Grafana::Variable.new(@from) if @from
-        url_vars['to'] = ::Grafana::Variable.new(@to) if @to
-        url_params = URI.encode_www_form(url_vars.map { |k, v| [k, v.raw_value.to_s] })
-        return '' if url_params.empty?
-
-        '?' + url_params
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative 'query_mixin'
+
+module GrafanaReporter
+  module Asciidoctor
+    # This class is used to query alerts from grafana.
+    class AlertsTableQuery < Grafana::AbstractQuery
+      include QueryMixin
+
+      # @option opts [Grafana::Dashboard] :dashboard  dashboard, if alerts shall be filtered for a dashboard
+      # @option opts [Grafnaa::Oanel] :panel panel, if alerts shall be filtered for a panel
+      def initialize(opts = {})
+        super()
+
+        @dashboard = opts[:dashboard]
+        @panel = opts[:panel]
+        @dashboard = @panel.dashboard if @panel
+
+        extract_dashboard_variables(@dashboard) if @dashboard
+      end
+
+      # @return [String] URL for querying alerts
+      def url
+        "/api/alerts#{url_parameters}"
+      end
+
+      # @return [Hash] empty hash object
+      def request
+        {}
+      end
+
+      # Check if mandatory {Grafana::Variable} +columns+ is specified in variables.
+      #
+      # The value of the +columns+ variable has to be a comma separated list of column titles, which
+      # need to be included in the following list:
+      # - limit
+      # - dashboardId
+      # - panelId
+      # - query
+      # - state
+      # - folderId
+      # - dashboardQuery
+      # - dashboardTag
+      # @return [void]
+      def pre_process(_grafana)
+        raise MissingMandatoryAttributeError, 'columns' unless @variables['columns']
+
+        @from = translate_date(@from, @variables['grafana-report-timestamp'], false, @variables['from_timezone'] ||
+                               @variables['grafana_default_from_timezone'])
+        @to = translate_date(@to, @variables['grafana-report-timestamp'], true, @variables['to_timezone'] ||
+                             @variables['grafana_default_to_timezone'])
+      end
+
+      # Filter the query result for the given columns and sets the result in the preformatted SQL
+      # result stlye.
+
+      # Additionally it applies {QueryMixin#format_columns}, {QueryMixin#replace_values} and
+      # {QueryMixin#filter_columns}.
+      # @return [void]
+      def post_process
+        # extract data from returned json
+        result = JSON.parse(@result.body)
+        content = []
+        begin
+          result.each { |item| content << item.fetch_values(*@variables['columns'].raw_value.split(',')) }
+        rescue KeyError => e
+          raise MalformedAttributeContentError.new(e.message, 'columns', @variables['columns'])
+        end
+
+        result = {}
+        result[:header] = [@variables['columns'].raw_value.split(',')]
+        result[:content] = content
+
+        result = format_columns(result, @variables['format'])
+        result = replace_values(result, @variables.select { |k, _v| k =~ /^replace_values_\d+/ })
+        result = filter_columns(result, @variables['filter_columns'])
+
+        @result = result[:content].map { |row| "| #{row.map { |item| item.to_s.gsub('|', '\\|') }.join(' | ')}" }
+      end
+
+      private
+
+      def url_parameters
+        url_vars = {}
+        url_vars['dashboardId'] = ::Grafana::Variable.new(@dashboard.id) if @dashboard
+        url_vars['panelId'] = ::Grafana::Variable.new(@panel.id) if @panel
+
+        url_vars.merge!(variables.select do |k, _v|
+          k =~ /^(?:limit|dashboardId|panelId|query|state|folderId|dashboardQuery|dashboardTag)/x
+        end)
+        url_vars['from'] = ::Grafana::Variable.new(@from) if @from
+        url_vars['to'] = ::Grafana::Variable.new(@to) if @to
+        url_params = URI.encode_www_form(url_vars.map { |k, v| [k, v.raw_value.to_s] })
+        return '' if url_params.empty?
+
+        "?#{url_params}"
+      end
+    end
+  end
+end