ruby-grafana-reporter 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aff73969c807020f8c39fe5a9c4095a3a8ee093e5fe94982a12f0899c057d44
-  data.tar.gz: 179f0d922e2a2a477c04cb91d4fffc692c99fdf394f78fef8ff6bfed0a0b5817
+  metadata.gz: '00728deba4250ed327170393bbeaac1b1d6d1002463a5a243285ac570f09231f'
+  data.tar.gz: 2985a11f6404e622ff279dbe3e328b38e4202bf665b2fef9e23746bbfd6c3459
 SHA512:
-  metadata.gz: e2d4730cbac1a089b9bb23eff305f5e6f9b189c66129370ab16400ec0edf993b8f5350305eccce29d4ffb1472d3e80d548be640ef4ac529babb14b3a8066e957
-  data.tar.gz: 74dfd8961382f3a9e0e35db3557a46762df27843f67cb17be6d0a3b530ff05de4ea09384a4beebfc40716f07b357ffa6eab1fbe0868c63140eeb7de6e2d3c5a1
+  metadata.gz: 92de552918a451f9bac1196dfbb05dc1ad64e0059f4c90fe06c079e5e181fee96a07858ae0c5815e3dbf37358c4aa271fcd8d129bb6721f3c8a53f285325fc25
+  data.tar.gz: aff95df6e4b5a8636905ec498433d1fcdae6d7b9aa2d26640815a68160c2f74c39078adfbe32a67c9115855ddd97683c6844ea0347e18cf010586e2bd036faed

data/README.md

@@ -12,6 +12,7 @@ Reporting Service for Grafana
 * [Getting started](#getting-started)
   * [Grafana integration](#grafana-integration)
   * [Webservice overview](#webservice-overview)
+* [Documentation](#documentation)
 * [Features](#features)
 * [Roadmap](#roadmap)
 * [Contributing](#contributing)
@@ -38,28 +39,28 @@ integrate without further dependencies with the asciidoctor docker image.
 Can't wait to see, what functions the reporter provides within the asciidoctor
 templates? Have a look at the [function documentation](FUNCTION_CALLS.md).
 
-The complete
-[API documentation](https://rubydoc.info/gems/ruby-grafana-reporter) can be
-found here.
-
 ## Getting started
 
-There exist several ways of installing the reporter. Here I cover the easiest
-setup by using ruby gems. If you need further installation help, or want to use
-a "baremetal" ruby setup or a docker integration, please have a look at the more
-extended [installation documentation](INSTALL.md).
+There exist several ways of installing the reporter. If you need further
+installation help, or want to use a "baremetal" ruby setup or a docker
+integration, please have a look at the more extended
+[installation documentation](INSTALL.md).
 
-To install the reporter as a gem, simply run:
+Windows users may directly use the provided executable.
 
+Following these steps sets up the reporter on a fresh Raspberry Pi installation:
+
+    sudo apt-get install ruby
     gem install ruby-grafana-reporter
 
-If no configuration file is in place, you might want to use the configuration
-wizard, which leads you through all necessary steps:
+That's it. Let's now configure a grafana setup with the configuration wizard:
 
     ruby-grafana-reporter -w
 
 It is strongly recommended, to also create the demo PDF file, as stated at the end
 of the procedure, to get a detailed documentation of all the reporter capabilities.
+The whole [function documentation](FUNCTION_CALLS.md) is also available at the
+previous link.
 
 To run the reporter as a service, you only need to call it like this:
 
@@ -112,39 +113,43 @@ Running the reporter as a webservice provides the following URLs
     /view_report - for viewing the status or receving the result of a specific rendering, is automatically called after a successfull /render call
     /cancel_report - for cancelling the rendering of a specific report, normally not called manually, but on user interaction in the /view_report or /overview URL
 
+The main endpoint to call for report generation is configured in the previous chapter [Grafana integration](#grafana-integration).
+
+However, if you would like to see, currently running report generations and previously generated reports, you may want to call the endpoint `/overview`.
+
+## Documentation
+
+The [function documentation](FUNCTION_CALLS.md) contains a complete overview of
+all possible grafana calls, to generate dynamic report templates.
+
+The [API documentation](https://rubydoc.info/gems/ruby-grafana-reporter) can be
+found here.
+
 ## Features
 
 * Build report template including all imaginable grafana content:
   * panels as images
   * panel table query or custom query results as real document tables (not images!)
   * single panel value or custom query single value result integrated in texts
-* Solid as a rock, also in case of template errors (at least it aims to be)
-* Runs standalone or as a webservice
+* Solid as a rock, also in case of template errors and whatever else may happen
+* Fully controllable as command line application or as a webservice
 * Seamlessly integrates with asciidoctor docker container
-* Developed for being able to support other tools than asciidoctor as well
+* Developed to support other tools than asciidoctor as well
 
 ## Roadmap
 
 This is just a collection of things, I am heading for in future, without a schedule.
 
-* Add documentation of possible asciidoctor calls to grafana
 * Add a simple plugin system to support specific asciidoctor modifications
 * Solve code TODOs
 * Become [rubocop](https://rubocop.org/) ready
+* Clean and properly setup test cases
 
 ## Contributing
 
 If you'd like to contribute, please fork the repository and use a feature
 branch. Pull requests are warmly welcome.
 
-Though not yet valid for my code, I'd like to see the project become
-[rubocop](https://rubocop.org/) ready :-)
-
-Definitely open spots from my side are:
-
-* This README
-* Clean and properly setup test cases
-
 ## Licensing
 
 The code in this project is licensed under MIT license.

data/bin/ruby-grafana-reporter

@@ -1,5 +1,5 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative '../lib/ruby-grafana-reporter'
-GrafanaReporter::Application::Application.new.configure_and_run(ARGV)
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/ruby-grafana-reporter'
+GrafanaReporter::Application::Application.new.configure_and_run(ARGV) unless defined?(Ocra)

data/lib/VERSION.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 # Version information
-GRAFANA_REPORTER_VERSION = [0, 2, 2].freeze
-GRAFANA_REPORTER_RELEASE_DATE = '2021-01-30'
+GRAFANA_REPORTER_VERSION = [0, 3, 0].freeze
+GRAFANA_REPORTER_RELEASE_DATE = '2021-03-02'

data/lib/grafana/grafana.rb

@@ -13,16 +13,15 @@ module Grafana
     #   trailing slash, e.g. +https://localhost:3000+.
     # @param key [String] API key for the grafana instance, if required
     # @param opts [Hash] additional options.
-    #   Currently supporting +:logger+ and +:datasources+.
-    #   +:datasources+ need to be an Hash with datasource name as key and datasource id as value.
-    #   If not specified, the datasources will be queried from the grafana interface.
-    #   Specifying +:datasources+> here can be used, so that the interface can be used without grafana Admin privileges.
+    #   Currently supporting +:logger+ and +:ssl_cert+.
     def initialize(base_uri, key = nil, opts = {})
       @base_uri = base_uri
       @key = key
       @dashboards = {}
+      @ssl_cert = opts[:ssl_cert]
       @logger = opts[:logger] || ::Logger.new(nil)
-      @datasources = opts[:datasources]
+
+      initialize_datasources unless @base_uri.empty?
     end
 
     # Used to test a connection to the grafana instance.
@@ -34,14 +33,13 @@ module Grafana
     def test_connection
       if execute_http_request('/api/datasources').is_a?(Net::HTTPOK)
         # we have admin rights
-        @logger.info('Reporter is running with Admin privileges on grafana.')
+        @logger.warn('Reporter is running with Admin privileges on grafana. This is a potential security risk.')
         return 'Admin'
       end
       # check if we have lower rights
       return 'Failed' unless execute_http_request('/api/dashboards/home').is_a?(Net::HTTPOK)
 
-      @logger.info('Reporter is running with NON-Admin privileges on grafana. Make sure that necessary '\
-                   'datasources are specified in CONFIG_FILE, otherwise operation will fail')
+      @logger.info('Reporter is running with NON-Admin privileges on grafana.')
       'NON-Admin'
     end
 
@@ -49,17 +47,17 @@ module Grafana
     #
     # @return [Integer] ID for the specified datasource name
     def datasource_id(datasource_name)
-      id = datasources[datasource_name]
-      raise DatasourceDoesNotExistError.new('name', datasource_name) unless id
+      datasource_name ||= 'default'
+      return @datasources[datasource_name] if @datasources[datasource_name]
 
-      id
+      raise DatasourceDoesNotExistError.new('name', datasource_name)
     end
 
     # Returns if the given datasource ID exists for the grafana instance.
     #
     # @return [Boolean] true if exists, false otherwise
     def datasource_id_exists?(datasource_id)
-      datasources.value?(datasource_id)
+      @datasources.value?(datasource_id)
     end
 
     # @param dashboard_uid [String] UID of the searched {Dashboard}
@@ -97,6 +95,13 @@ module Grafana
       if @base_uri =~ /^https/
         http.use_ssl = true
         http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        if @ssl_cert && !File.exist?(@ssl_cert)
+          @logger.warn('SSL certificate file does not exist.')
+        elsif @ssl_cert
+          http.cert_store = OpenSSL::X509::Store.new
+          http.cert_store.set_default_paths
+          http.cert_store.add_file(@ssl_cert)
+        end
       end
       http.read_timeout = timeout.to_i if timeout
 
@@ -112,19 +117,17 @@ module Grafana
 
     private
 
-    def datasources
-      if @datasources.nil?
-        # load datasources from grafana directly, if allowed
-        response = execute_http_request('/api/datasources')
-        if response['message'].nil?
-          json = JSON.parse(response.body)
-          # only store needed values
-          @datasources = json.map { |item| [item['name'], item['id']] }.to_h
-        else
-          @datasources = {}
-        end
+    def initialize_datasources
+      @datasources = {}
+
+      settings = execute_http_request('/api/frontend/settings')
+      return unless settings.is_a?(Net::HTTPOK)
+
+      json = JSON.parse(settings.body)
+      json['datasources'].select { |_k, v| v['id'].to_i.positive? }.each do |ds_name, ds_value|
+        @datasources[ds_name] = ds_value['id'].to_i
       end
-      @datasources
+      @datasources['default'] = @datasources[json['defaultDatasource']]
     end
   end
 end

data/lib/grafana_reporter/application/application.rb

@@ -33,7 +33,11 @@ module GrafanaReporter
         action_wizard = false
 
         parser = OptionParser.new do |opts|
-          opts.banner = "Usage: ruby #{$PROGRAM_NAME} [options]"
+          if ENV['OCRA_EXECUTABLE']
+            opts.banner = "Usage: #{ENV['OCRA_EXECUTABLE'].gsub("#{Dir.pwd}/".gsub('/', '\\'), '')} [options]"
+          else
+            opts.banner = "Usage: #{Gem.ruby} #{$PROGRAM_NAME} [options]"
+          end
 
           opts.on('-c', '--config CONFIG_FILE_NAME', 'Specify custom configuration file,'\
                   " instead of #{CONFIG_FILE}.") do |file_name|
@@ -48,11 +52,22 @@ module GrafanaReporter
             tmp_config.set_param('to_file', file)
           end
 
-          opts.on('-s', '--set VARIABLE,VALUE', Array, 'Set a variable value, which will be passed to the rendering') do |list|
-            raise ParameterValueError.new(list.length) unless list.length == 2
+          opts.on('-s', '--set VARIABLE,VALUE', Array, 'Set a variable value, which will be passed to the '\
+                  'rendering') do |list|
+            raise ParameterValueError, list.length unless list.length == 2
+
             tmp_config.set_param("default-document-attributes:#{list[0]}", list[1])
           end
 
+          opts.on('--ssl-cert FILE', 'Manually specify a SSL cert file for HTTPS connection to grafana. Only '\
+                  'needed if not working properly otherwise.') do |file|
+            if File.exist?(file)
+              tmp_config.set_param('grafana-reporter:ssl-cert', file)
+            else
+              config.logger.warn("SSL certificate file #{file} does not exist. Setting will be ignored.")
+            end
+          end
+
           opts.on('--test GRAFANA_INSTANCE', 'test current configuration against given GRAFANA_INSTANCE') do |instance|
             tmp_config.set_param('grafana-reporter:run-mode', 'test')
             tmp_config.set_param('grafana-reporter:test-instance', instance)
@@ -80,7 +95,7 @@ module GrafanaReporter
 
         begin
           parser.parse!(params)
-          return config_wizard(config_file) if action_wizard
+          return ConsoleConfigurationWizard.new.start_wizard(config_file, tmp_config) if action_wizard
         rescue ApplicationError => e
           puts e.message
           return -1
@@ -122,7 +137,7 @@ module GrafanaReporter
         when Configuration::MODE_CONNECTION_TEST
           res = Grafana::Grafana.new(config.grafana_host(config.test_instance),
                                      config.grafana_api_key(config.test_instance),
-                                     logger: config.logger).test_connection
+                                     logger: config.logger, ssl_cert: config.ssl_cert).test_connection
           puts res
 
         when Configuration::MODE_SINGLE_RENDER
@@ -138,271 +153,6 @@ module GrafanaReporter
 
         0
       end
-
-      private
-
-      # Provides a command line configuration wizard for setting up the necessary configuration
-      # file.
-      def config_wizard(config_file)
-        if File.exist?(config_file)
-          input = nil
-          until input
-            input = user_input("Configuration file '#{config_file}' already exists. Do you want to overwrite it?", 'yN')
-            return if input =~ /^(?:n|N|yN)$/
-          end
-        end
-
-        puts 'This wizard will guide you through an initial configuration for'\
-             ' the ruby-grafana-reporter. The configuration file will be created'\
-             ' in the current folder. Please make sure to specify necessary paths'\
-             ' either with a relative or an absolute path properly.'
-        puts
-	puts "Wizard is creating configuration file '#{config_file}'."
-	puts
-        port = ui_config_port
-        grafana = ui_config_grafana
-        templates = ui_config_templates_folder
-        reports = ui_config_reports_folder
-        images = ui_config_images_folder(templates)
-        retention = ui_config_retention
-
-        config_yaml = %(# This configuration has been built with the configuration wizard.
-
-#{grafana}
-
-grafana-reporter:
-  report-class: GrafanaReporter::Asciidoctor::Report
-  templates-folder: #{templates}
-  reports-folder: #{reports}
-  report-retention: #{retention}
-  webservice-port: #{port}
-
-default-document-attributes:
-  imagesdir: #{images}
-# feel free to add here additional asciidoctor document attributes which are applied to all your templates
-)
-
-        begin
-          File.write(config_file, config_yaml, mode: 'w')
-          puts 'Configuration file successfully created.'
-        rescue StandardError => e
-          raise e
-        end
-
-        config = Configuration.new
-        begin
-          config.config = YAML.load_file(config_file)
-          puts 'Configuration file validated successfully.'
-        rescue StandardError => e
-          raise ConfigurationError, "Could not read config file '#{config_file}' (Error: #{e.message})\n"\
-                "Source:\n#{File.read(config_file)}"
-        end
-
-        # create a demo report
-        unless Dir.exist?(config.templates_folder)
-          puts "Skip creation of DEMO template, as folder '#{config.templates_folder}' does not exist."
-          return
-        end
-        demo_report = %(= First Grafana Report Template
-
-include::grafana_help[]
-
-include::grafana_environment[])
-
-        demo_report_file = "#{config.templates_folder}demo_report.adoc"
-        if File.exist?(demo_report_file)
-          puts "Skip creation of DEMO template, as file '#{demo_report_file}' already exists."
-        else
-          begin
-            File.write(demo_report_file, demo_report, mode: 'w')
-            puts "DEMO template '#{demo_report_file}' successfully created."
-          rescue StandardError => e
-            raise e
-          end
-        end
-
-        puts
-        puts 'Now everything is setup properly. To create an initial report including a manual of all reporter '\
-             'capabilities with the newly created configuration, call the following command:'
-        puts
-        puts "   ruby-grafana-reporter -c #{config_file} -t #{demo_report_file} -o demo_report_with_help.pdf"
-        puts
-        puts 'To start the reporter as a service, call the following command:'
-        puts
-        puts "   ruby-grafana-reporter -c #{config_file}"
-        puts
-        puts "Open 'http://localhost:#{config.webserver_port}/render?var-template=demo_report' in a webbrowser to"
-        puts 'verify your configuration.'
-      end
-
-      def ui_config_grafana
-        valid = false
-        url = nil
-        api_key = nil
-        datasources = ''
-        until valid
-          url ||= user_input('Specify grafana host', 'http://localhost:3000')
-          print "Testing connection to '#{url}' #{api_key ? '_with_' : '_without_'} API key..."
-          begin
-            res = Grafana::Grafana.new(url,
-                                       api_key,
-                                       logger: config.logger).test_connection
-          rescue StandardError => e
-            puts
-            puts e.message
-          end
-          puts 'done.'
-
-          case res
-          when 'Admin'
-            valid = true
-
-          when 'NON-Admin'
-            print 'Access to grafana is permitted as NON-Admin. Do you want to use an [a]pi key,'\
-                  ' configure [d]atasource manually, [r]e-enter api key or [i]gnore? [adRi]: '
-
-            case gets
-            when /(?:i|I)$/
-              valid = true
-
-            when /(?:a|A)$/
-              print 'Enter API key: '
-              api_key = gets.sub(/\n$/, '')
-
-            when /(?:r|R|adRi)$/
-              api_key = nil
-
-            when /(?:d|D)$/
-              valid = true
-              datasources = ui_config_datasources
-
-            end
-
-          else
-            print "Grafana could not be accessed at '#{url}'. Do you want do [r]e-enter url, or"\
-                 ' [i]gnore and proceed? [Ri]: '
-
-            case gets
-            when /(?:i|I)$/
-              valid = true
-
-            else
-              url = nil
-              api_key = nil
-
-            end
-
-          end
-        end
-        %(grafana:
-  default:
-    host: #{url}#{api_key ? "\n    api_key: #{api_key}" : ''}#{datasources ? "\n#{datasources}" : ''}
-)
-      end
-
-      def ui_config_datasources
-        finished = false
-        datasources = []
-        until finished
-          item = {}
-          print "Datasource ###{datasources.length + 1}) Enter datasource name as configured in grafana: "
-          item[:ds_name] = gets.sub(/\n$/, '')
-          print "Datasource ###{datasources.length + 1}) Enter datasource id: "
-          item[:ds_id] = gets.sub(/\n$/, '')
-
-          puts
-          selection = user_input("Datasource name: '#{item[:ds_name]}', Datasource id: '#{item[:ds_id]}'."\
-                                 ' [A]ccept, [r]etry or [c]ancel?', 'Arc')
-
-          case selection
-          when /(?:Arc|A|a)$/
-            datasources << item
-            another = user_input('Add [a]nother datasource or [d]one?', 'aD')
-            finished = true if another =~ /(?:d|D)$/
-
-          when /(?:c|C)$/
-            finished = true
-
-          end
-        end
-        "    datasources:\n#{datasources.collect { |el| "      #{el[:ds_name]}: #{el[:ds_id]}" }.join('\n')}"
-      end
-
-      def ui_config_port
-        input = nil
-        until input
-          input = user_input('Specify port on which reporter shall run', '8815')
-          input = nil unless input =~ /[0-9]+/
-        end
-        input
-      end
-
-      def ui_config_templates_folder
-        input = nil
-        until input
-          input = user_input('Specify path where templates shall be stored', './templates')
-          input = nil unless validate_config_folder(input)
-        end
-        input
-      end
-
-      def ui_config_reports_folder
-        input = nil
-        until input
-          input = user_input('Specify path where created reports shall be stored', './reports')
-          input = nil unless validate_config_folder(input)
-        end
-        input
-      end
-
-      def ui_config_images_folder(parent)
-        input = nil
-        until input
-          input = user_input('Specify path where rendered images shall be stored (relative to templates folder)',
-                             './images')
-          input = nil unless validate_config_folder(File.join(parent, input))
-        end
-        input
-      end
-
-      def ui_config_retention
-        input = nil
-        until input
-          input = user_input('Specify report retention duration in hours', '24')
-          input = nil unless input =~ /[0-9]+/
-        end
-        input
-      end
-
-      def user_input(text, default)
-        print "#{text} [#{default}]: "
-        input = gets.gsub(/\n$/, '')
-        input = default if input.empty?
-        input
-      end
-
-      def validate_config_folder(folder)
-        return true if Dir.exist?(folder)
-
-        print "Directory '#{folder} does not exist: [c]reate, [r]e-enter path or [i]gnore? [cRi]: "
-        case gets
-        when /^(?:c|C)$/
-          begin
-            Dir.mkdir(folder)
-            puts "Directory '#{folder}' successfully created."
-            return true
-          rescue StandardError => e
-            puts "WARN: Directory '#{folder}' could not be created. Please create it manually."
-            puts e.message
-          end
-
-        when /^(?:i|I)$/
-          puts "WARN: Directory '#{folder}' does not exist. Please create manually."
-          return true
-        end
-
-        false
-      end
     end
   end
 end