ruby-grafana-reporter 0.1.7 → 0.2.0

data/lib/grafana_reporter/abstract_report.rb

@@ -1,109 +1,112 @@
-module GrafanaReporter
-  # @abstract Override {#create_report} and {#progress}.
-  #
-  # This class is used to build a report on basis of a given configuration and
-  # template.
-  #
-  # Objects of this class are also stored in {Application::Application}, unless
-  # the retention time is over.
-  class AbstractReport
-    # @return [String] path to the template
-    attr_reader :template
-
-    # @return [Time] time, when the report generation started
-    attr_reader :start_time
-
-    # @return [Time] time, when the report generation ended
-    attr_reader :end_time
-
-    # @return [Logger] logger object used during report generation
-    attr_reader :logger
-
-    # @return [Boolean] true, if the report is or shall be cancelled
-    attr_reader :cancel
-
-    # @return [Boolen] true, if the report generation is finished (successfull or not)
-    attr_reader :done
-
-    # @param config [Configuration] configuration object
-    # @param template [String] path to the template to be used
-    # @param destination_file_or_path [String or File] path to the destination report or file object to use
-    # @param custom_attributes [Hash] custom attributes, which shall be merged with priority over the configuration
-    def initialize(config, template, destination_file_or_path = nil, custom_attributes = {})
-      @config = config
-      @logger = Logger::TwoWayDelegateLogger.new
-      @logger.additional_logger = @config.logger
-      @done = false
-      @template = template
-      @destination_file_or_path = destination_file_or_path
-      @custom_attributes = custom_attributes
-      @start_time = nil
-      @end_time = nil
-      @cancel = false
-      raise MissingTemplateError, @template.to_s unless File.exist?(@template.to_s)
-    end
-
-    # Call to request cancelling the report generation.
-    # @return [void]
-    def cancel!
-      @cancel = true
-      logger.info('Cancelling report generation invoked.')
-    end
-
-    # @return [String] path to the report destination file
-    def path
-      @destination_file_or_path.respond_to?(:path) ? @destination_file_or_path.path : @destination_file_or_path
-    end
-
-    # Deletes the report file object.
-    # @return [void]
-    def delete_file
-      if @destination_file_or_path.is_a?(Tempfile)
-        @destination_file_or_path.unlink
-      elsif @destination_file_or_path.is_a?(File)
-        @destination_file_or_path.delete
-      end
-      @destination_file_or_path = nil
-    end
-
-    # @return [Float] time in seconds, that the report generation took
-    def execution_time
-      return nil if start_time.nil?
-      return end_time - start_time unless end_time.nil?
-
-      Time.now - start_time
-    end
-
-    # @return [Array] error messages during report generation.
-    def error
-      @error || []
-    end
-
-    # @return [String] status of the report, one of 'in progress', 'cancelled', 'died' or 'finished'.
-    def status
-      return 'cancelled' if done && cancel
-      return 'finished' if done && error.empty?
-      return 'died' if done && !error.empty?
-
-      'in progress'
-    end
-
-    # @return [String] string containing all messages ([Logger::Severity::DEBUG]) of the logger during report generation.
-    def full_log
-      logger.internal_messages
-    end
-
-    # @abstract
-    # Is being called to start the report generation.
-    # @return [void]
-    def create_report
-      raise NotImplementedError
-    end
-
-    # @abstract
-    # @return [Integer] number between 0 and 100, representing the current progress of the report creation.
-    def progress
-      raise NotImplementedError
-    end
-  end
-end
+# frozen_string_literal: true
+
+module GrafanaReporter
+  # @abstract Override {#create_report} and {#progress}.
+  #
+  # This class is used to build a report on basis of a given configuration and
+  # template.
+  #
+  # Objects of this class are also stored in {Application::Application}, unless
+  # the retention time is over.
+  class AbstractReport
+    # @return [String] path to the template
+    attr_reader :template
+
+    # @return [Time] time, when the report generation started
+    attr_reader :start_time
+
+    # @return [Time] time, when the report generation ended
+    attr_reader :end_time
+
+    # @return [Logger] logger object used during report generation
+    attr_reader :logger
+
+    # @return [Boolean] true, if the report is or shall be cancelled
+    attr_reader :cancel
+
+    # @return [Boolen] true, if the report generation is finished (successfull or not)
+    attr_reader :done
+
+    # @param config [Configuration] configuration object
+    # @param template [String] path to the template to be used
+    # @param destination_file_or_path [String or File] path to the destination report or file object to use
+    # @param custom_attributes [Hash] custom attributes, which shall be merged with priority over the configuration
+    def initialize(config, template, destination_file_or_path = nil, custom_attributes = {})
+      @config = config
+      @logger = Logger::TwoWayDelegateLogger.new
+      @logger.additional_logger = @config.logger
+      @done = false
+      @template = template
+      @destination_file_or_path = destination_file_or_path
+      @custom_attributes = custom_attributes
+      @start_time = nil
+      @end_time = nil
+      @cancel = false
+      raise MissingTemplateError, @template.to_s unless File.exist?(@template.to_s)
+    end
+
+    # Call to request cancelling the report generation.
+    # @return [void]
+    def cancel!
+      @cancel = true
+      logger.info('Cancelling report generation invoked.')
+    end
+
+    # @return [String] path to the report destination file
+    def path
+      @destination_file_or_path.respond_to?(:path) ? @destination_file_or_path.path : @destination_file_or_path
+    end
+
+    # Deletes the report file object.
+    # @return [void]
+    def delete_file
+      if @destination_file_or_path.is_a?(Tempfile)
+        @destination_file_or_path.unlink
+      elsif @destination_file_or_path.is_a?(File)
+        @destination_file_or_path.delete
+      end
+      @destination_file_or_path = nil
+    end
+
+    # @return [Float] time in seconds, that the report generation took
+    def execution_time
+      return nil if start_time.nil?
+      return end_time - start_time unless end_time.nil?
+
+      Time.now - start_time
+    end
+
+    # @return [Array] error messages during report generation.
+    def error
+      @error || []
+    end
+
+    # @return [String] status of the report, one of 'in progress', 'cancelled', 'died' or 'finished'.
+    def status
+      return 'cancelled' if done && cancel
+      return 'finished' if done && error.empty?
+      return 'died' if done && !error.empty?
+
+      'in progress'
+    end
+
+    # @return [String] string containing all messages ([Logger::Severity::DEBUG]) of the logger during report
+    #   generation.
+    def full_log
+      logger.internal_messages
+    end
+
+    # @abstract
+    # Is being called to start the report generation.
+    # @return [void]
+    def create_report
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @return [Integer] number between 0 and 100, representing the current progress of the report creation.
+    def progress
+      raise NotImplementedError
+    end
+  end
+end

data/lib/grafana_reporter/application/application.rb

@@ -1,229 +1,404 @@
-module GrafanaReporter
-  # This module contains all classes, which are used by the grafana reporter
-  # application. The application is a set of classes, which allows to run the
-  # reporter in several ways.
-  #
-  # If you intend to use the reporter functionality, without the application,
-  # it might be helpful to not use the classes from here.
-  module Application
-    # This class contains the main application to run the grafana reporter.
-    #
-    # It can be run to test the grafana connection, render a single template
-    # or run as a service.
-    class Application
-      def initialize
-        @logger = ::Logger.new(STDERR, level: :unknown)
-        @reports = []
-      end
-
-      # Can be used to set a {Configuration} object to the application.
-      #
-      # This is mainly helpful in testing the application or in an
-      # integrated use.
-      # @param config {Configuration} configuration to be used by the application
-      # @return [void]
-      def config=(config)
-        @logger = config.logger || @logger
-        @config = config
-      end
-
-      # This is the main method, which is called, if the application is
-      # run in standalone mode.
-      # @param params [Array] normally the ARGV command line parameters
-      # @return [Integer] see {#run}
-      def configure_and_run(params = [])
-        config = GrafanaReporter::Configuration.new
-        config.logger.level = ::Logger::Severity::INFO
-        result = config.configure_by_command_line(params)
-        return result if result != 0
-
-        self.config = config
-        run
-      end
-
-      # Runs the application with the current set {Configuration} object.
-      # @return [Integer] value smaller than 0, if error. 0 if successfull
-      def run
-        begin
-          @config.validate
-        rescue ConfigurationError => e
-          puts e.message
-          return -2
-        end
-
-        case @config.mode
-        when Configuration::MODE_CONNECTION_TEST
-          res = Grafana::Grafana.new(@config.grafana_host(@config.test_instance), @config.grafana_api_key(@config.test_instance), logger: @logger).test_connection
-          puts res
-
-        when Configuration::MODE_SINGLE_RENDER
-          @config.report_class.new(@config, @config.template, @config.to_file).create_report
-
-        when Configuration::MODE_SERVICE
-          run_webserver
-        end
-        0
-      end
-
-      private
-
-      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 run_webserver
-        # start webserver
-        server = TCPServer.new(@config.webserver_port)
-        @logger.info("Server listening on port #{@config.webserver_port}...")
-
-        @progress_reporter = Thread.new {}
-
-        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
-
-          unless @progress_reporter.alive?
-            @progress_reporter = Thread.new do
-              running_reports = @reports.reject(&:done)
-              until running_reports.empty?
-                @logger.info("#{running_reports.length} report(s) in progress: #{running_reports.map { |report| (report.progress * 100).to_i.to_s + '% (running ' + report.execution_time.to_i.to_s + ' secs)' }.join(', ')}") unless running_reports.empty?
-                sleep 5
-                running_reports = @reports.reject(&:done)
-              end
-              # puts "no more running reports - stopping to report progress"
-            end
-          end
-
-          clean_outdated_temporary_reports
-        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.to_s)
-
-        # read URL parameters
-        attrs = {}
-        query_parameters.each do |k, v|
-          attrs[k] = v.length == 1 ? v[0] : v
-        end
-
-        if request.split("\r\n")[0] =~ %r{^GET /render[\? ]}
-          # build report
-          template_file = @config.templates_folder.to_s + attrs['var-template'].to_s + '.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
-
-          return http_response(302, 'Found', nil, Location: "/view_report?report_id=#{report.object_id}")
-
-        elsif request.split("\r\n")[0] =~ %r{^GET /overview[\? ]}
-          # show overview for current reports
-          return get_reports_status_as_html(@reports)
-
-        elsif request.split("\r\n")[0] =~ %r{^GET /view_report[\? ]}
-          # 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)
-          return http_response(200, 'OK', content, "Content-Type": 'application/pdf') if content.start_with?("%PDF")
-          # TODO properly provide file as zip
-          return http_response(200, 'OK', content, "Content-Type": 'application/octet-stream', "Content-Disposition": "attachment; filename=report.zip")
-
-        elsif request.split("\r\n")[0] =~ %r{^GET /cancel_report[\? ]}
-          # 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
-          return http_response(302, 'Found', nil, Location: "/view_report?report_id=#{report.object_id}")
-
-        elsif request.split("\r\n")[0] =~ %r{^GET /view_log[\? ]}
-          # 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
-
-          return  http_response(200, 'OK', content, "Content-Type": 'text/plain')
-        end
-
-        raise WebserviceUnknownPathError, request.split("\r\n")[0]
-      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
+# frozen_string_literal: true
+
+module GrafanaReporter
+  # This module contains all classes, which are used by the grafana reporter
+  # application. The application is a set of classes, which allows to run the
+  # reporter in several ways.
+  #
+  # If you intend to use the reporter functionality, without the application,
+  # it might be helpful to not use the classes from here.
+  module Application
+    # This class contains the main application to run the grafana reporter.
+    #
+    # It can be run to test the grafana connection, render a single template
+    # or run as a service.
+    class Application
+      # Default file name for grafana reporter configuration file
+      CONFIG_FILE = 'grafana_reporter.config'
+
+      def initialize
+        @logger = ::Logger.new($stdout, level: :unknown)
+      end
+
+      # Contains the {Configuration} object of the application.
+      attr_accessor :config
+
+      # This is the main method, which is called, if the application is
+      # run in standalone mode.
+      # @param params [Array<String>] command line parameters, mainly ARGV can be used.
+      # @return [Integer] 0 if everything is fine, -1 if execution aborted.
+      def configure_and_run(params = [])
+        config_file = CONFIG_FILE
+        cli_config = {}
+        cli_config ['grafana-reporter'] = {}
+        cli_config ['default-document-attributes'] = {}
+
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: ruby #{$PROGRAM_NAME} [options]"
+
+          opts.on('-c', '--config CONFIG_FILE_NAME', 'Specify custom configuration file,'\
+                  " instead of #{CONFIG_FILE}.") do |file_name|
+            config_file = file_name
+          end
+
+          opts.on('-d', '--debug LEVEL', 'Specify detail level: FATAL, ERROR, WARN, INFO, DEBUG.') do |level|
+            if level =~ /(?:FATAL|ERROR|WARN|INFO|DEBUG)/
+              @logger.level = Object.const_get("::Logger::Severity::#{level}")
+            end
+          end
+
+          opts.on('-o', '--output FILE', 'Output filename if only a single file is rendered') do |file|
+            cli_config['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
+            cli_config['default-document-attributes'][list[0]] = list[1]
+          end
+
+          opts.on('--test GRAFANA_INSTANCE', 'test current configuration against given GRAFANA_INSTANCE') do |instance|
+            cli_config['grafana-reporter']['run-mode'] = 'test'
+            cli_config['grafana-reporter']['test-instance'] = instance
+          end
+
+          opts.on('-t', '--template TEMPLATE', 'Render a single ASCIIDOC template to PDF and exit') do |template|
+            cli_config['grafana-reporter']['run-mode'] = 'single-render'
+            cli_config['default-document-attributes']['var-template'] = template
+          end
+
+          opts.on('-w', '--wizard', 'Configuration wizard to prepare environment for the reporter.') do
+            return config_wizard
+          end
+
+          opts.on('-v', '--version', 'Version information') do
+            puts GRAFANA_REPORTER_VERSION.join('.')
+            return -1
+          end
+
+          opts.on('-h', '--help', 'Show this message') do
+            puts opts
+            return -1
+          end
+        end
+
+        begin
+          parser.parse!(params)
+        rescue ApplicationError => e
+          puts e.message
+          return -1
+        end
+
+        # abort if config file does not exist
+        unless File.exist?(config_file)
+          puts "Config file '#{config_file}' does not exist. Consider calling the configuration wizard"\
+               ' with option \'-w\' or use \'-h\' to see help message. Aborting.'
+          return -1
+        end
+
+        # read config file
+        @config = GrafanaReporter::Configuration.new
+        config.logger = @logger
+        config_hash = nil
+        begin
+          config_hash = YAML.load_file(config_file)
+        rescue StandardError => e
+          raise ConfigurationError, "Could not read config file '#{config_file}' (Error: #{e.message})"
+        end
+
+        # merge command line configuration with read config file
+        config_hash.merge!(cli_config) { |_key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2) : v2 }
+        config.config = config_hash
+
+        run
+      end
+
+      # Runs the application with the current set {Configuration} object.
+      # @return [Integer] value smaller than 0, if error. 0 if successfull
+      def run
+        begin
+          config.validate
+        rescue ConfigurationError => e
+          puts e.message
+          return -2
+        end
+
+        case config.mode
+        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
+          puts res
+
+        when Configuration::MODE_SINGLE_RENDER
+          begin
+            config.report_class.new(config, config.template, config.to_file).create_report
+          rescue StandardError => e
+            puts e.message
+          end
+
+        when Configuration::MODE_SERVICE
+          Webservice.new(config).run
+        end
+
+        0
+      end
+
+      private
+
+      # Provides a command line configuration wizard for setting up the necessary configuration
+      # file.
+      def config_wizard
+        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
+        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:
+  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. Run the grafana reporter without any command to start the service.'
+        puts
+        puts '   ruby-grafana-reporter'
+        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: @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