test_server 0.0.11

data/app/controllers/streaming_controller.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module TestServer
+  module App
+    class StreamingController < ApplicationController
+      helpers Sinatra::Streaming
+
+      before do
+        param :base64, Boolean, default: false
+      end
+
+      helpers do
+        def stream_data(&block)
+          content_type :stream
+          cache_control :no_cache, :must_revalidate
+
+          stream(&block)
+        end
+      end
+
+      configure do
+        mime_type :stream, 'text/plain'
+      end
+
+      get '/' do
+        redirect to('/default/')
+      end
+
+      get '/default/?:count?' do
+        param :count, Integer, default: 10
+
+        count = params[:count]
+
+        stream_data do |out|
+          out << encode { "Data #{count} times repeated" }
+
+          count.times do |n|
+            out << encode { "#{n + 1}: data" }
+            sleep 1
+          end
+        end
+      end
+
+      get '/eicar/' do
+        stream_data do |out|
+          generate_eicar.each do |c|
+            out << encode { c }
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/string_controller.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module TestServer
+  module App
+    class StringController < ApplicationController
+
+      before do
+        param :no_cache, Boolean, default: false
+        param :must_revalidate, Boolean, default: false
+        param :max_age, Integer
+        param :base64, Boolean, default: false
+
+        configure_caching(params)
+      end
+
+      get '/' do
+        redirect to('/default/')
+      end
+
+      get '/default/?:count?' do
+        param :count, Integer, default: 1
+
+        encode do
+          generate_string(params[:count])
+        end
+      end
+
+      get '/eicar/' do
+        encode do
+          generate_eicar.join
+        end
+      end
+
+      get '/sleep/?:count?' do
+        param :count, Integer, default: 120
+        sleep params[:count]
+
+        encode do
+          generate_string(1)
+        end
+      end
+
+      get '/random/?:count?' do
+        param :count, Integer, default: 10
+
+        encode do
+          generate_random_string(params[:count])
+        end
+      end
+    end
+  end
+end

data/app/views/application.haml

@@ -0,0 +1,19 @@
+!!!
+%html
+  %head
+    %meta{ charset: 'utf-8'}
+    %link{ rel: 'stylesheet', href: stylesheet_path('application.css') }
+    %title= @title || t('views.application.title')
+  %body
+    .ts-page-header
+      %nav.ts-top-navigation
+        %ul.nav.navbar-nav
+          %li
+            %a{href: '/'}
+              = t('views.root.link')
+          %li.active
+            %a{href: '/v1/test/'}
+              = t('views.test.link')
+    .ts-container
+      = yield
+    %script{ type: 'text/javascript', src: javascript_path('application.js') }

data/app/views/xhr/show.haml

@@ -0,0 +1,38 @@
+%form#form.ts-form{ name: 'form', action: '', role: :form }
+  .ts-form-group
+    %label{ for: :count}
+      = t('views.javascript.xhr.fields.count')
+    %input#count.ts-field-count{ type: :number, name: :count, value: @count }
+  .ts-form-group
+    %label{ for: :timeout}
+      = t('views.javascript.xhr.fields.timeout')
+    %input#timeout.ts-field-timeout{ type: :number, name: :timeout, value: @timeout }
+  .ts-form-group
+    %label{ for: :url}
+      = t('views.javascript.xhr.fields.url')
+    %input#url.ts-field-url{ type: :url, name: :url, value: @url }
+  %button#submit.ts-button-submit{type: 'submit', value: t('views.application.buttons.submit'), 'data-toggle' => 'modal', 'data-target' => '#notification'}
+    = t('views.application.buttons.submit')
+  %a#reset.ts-button-reset{href: '#'}
+    = t('views.application.buttons.reset')
+
+%table#result.ts-result-table
+  %th= t('views.javascript.xhr.result_table.url') 
+  %th= t('views.javascript.xhr.result_table.timeout') 
+  %th= t('views.javascript.xhr.result_table.runtime') 
+  %th= t('views.javascript.xhr.result_table.status') 
+
+.modal#notification{ role: 'dialog' , tabindex: '-1'}
+  .modal-dialog
+    .modal-content
+      .modal-header
+        %button.ts-button-close-headline{ type: 'button', 'data-dismiss' => 'modal', 'aria-hidden' => 'true'} 
+          ×
+        %h4 
+          = t('views.dialogs.notification.title')
+      .modal-body
+        %p.ts-text-centered 
+          = t('views.javascript.xhr.notification.text')
+      .modal-footer
+        %button.ts-button-close{ type: 'button', 'data-dismiss' => 'modal' }
+          = t('views.application.buttons.close')

data/bin/test_server

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+$LOAD_PATH << ::File.expand_path('../../lib', __FILE__)
+require 'test_server'
+
+begin
+  TestServer::Cli::Main.start
+rescue StandardError => e
+  TestServer::Actions::HandleError.new(e).run
+end

data/bower.json

@@ -0,0 +1,8 @@
+{
+  "name": "test_server",
+  "dependencies": {
+    "bootstrap-sass": "~3.0.2",
+    "jquery": "~2.1.0",
+    "open-sans": "latest"
+  }
+}

data/config.ru

@@ -0,0 +1,51 @@
+$LOAD_PATH <<::File.expand_path('../lib/', __FILE__)
+
+require 'sass'
+require 'test_server'
+#require 'bundler'
+
+#if %w{ development test }.include? ENV['RACK_ENV']
+#  Bundler.require :default, :test, :development
+#else
+#  Bundler.require :default
+#end
+
+TestServer.config.debug_mode = true if ENV['DEBUG']
+TestServer.config.log_level = ENV['LOG_LEVEL'] if ENV['LOG_LEVEL']
+TestServer.config.access_log = ENV['ACCESS_LOG'] if ENV['ACCESS_LOG']
+
+TestServer.ui_logger.level = TestServer.config.log_level
+
+require File.expand_path('../app/controllers/application_controller.rb', __FILE__)
+Dir.glob(::File.expand_path('../app/controllers/*.rb', __FILE__)).each { |f| require f }
+
+
+trap TestServer.config.reload_config_signal do
+  begin
+    TestServer.ui_logger.warn 'Reload of configuration requested'
+    TestServer::Actions::ReloadConfiguration.new.run
+    TestServer.ui_logger.info 'Reload of configuration successful'
+  rescue Exceptions::ReloadOfConfigurationFailed => e
+    TestServer.ui_logger.fatal "Reload of configuration failed: #{e.message}"
+  end
+end
+
+#map '/v1/testrating/' do
+#  run TestServer::App::TestRatingController
+#end
+
+map '/v1/test/streaming' do
+  run TestServer::App::StreamingController
+end
+
+map '/v1/test/string' do
+  run TestServer::App::StringController
+end
+
+map '/v1/test/javascript' do
+  run TestServer::App::JavascriptController
+end
+
+map TestServer::App::AssetsController.assets_prefix do
+  run TestServer::App::AssetsController.assets
+end

data/files/config.yaml

@@ -0,0 +1 @@
+---

data/files/example-config.erb

@@ -0,0 +1,12 @@
+---
+# You might want to copy the following output to one of the allowed config
+# file paths - in the given order. But be aware that at 
+# <%= lookup('config_file') -%>, there might be a 
+# config file created during initialization.
+<% Array(lookup('allowed_config_file_paths')).each do |p| -%>
+# * <%= p %>
+<% end -%>
+
+<% TestServer::Config.options.delete_if { |o| [:expand_path, :gem_path].include? o }.each do |o| -%>
+:<%= o %>: <%= lookup(o) %>
+<% end -%>

data/lib/test_server/access_logger.rb

@@ -0,0 +1,13 @@
+module TestServer
+  class AccessLogger
+    def initialize(path)
+      @logger = ::Logger.new(::File.expand_path(path))
+    rescue Errno::ENOENT
+      raise Exceptions::AccessLogPathInvalid, JSON.dump(file: path, directory: ::File.dirname(path) )
+    end
+
+    def write(*args, &block)
+      @logger.<<(*args, &block)
+    end
+  end
+end

data/lib/test_server/actions/create_directory.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module TestServer
+  module Actions
+    class CreateDirectory
+      private
+
+      attr_reader :fs_engine, :path, :options
+
+      public
+
+      def initialize(path, options = {}, fs_engine = FileUtils)
+        @path      =::File.expand_path(path)
+        @options   = options
+        @fs_engine = fs_engine
+      end
+
+      def run
+        if need_to_run? || options[:force] == true
+          TestServer.ui_logger.warn "Creating directory \"#{path}\"."
+          fs_engine.mkdir_p(path)
+        else
+          TestServer.ui_logger.warn "Directory \"#{path}\" already exists. Do not create it again!."
+        end
+      end
+
+      private
+
+      def need_to_run?
+        !::File.exists?(path)
+      end
+    end
+  end
+end

data/lib/test_server/actions/create_file.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module TestServer
+  module Actions
+    class CreateFile
+      private
+
+      attr_reader :name, :destination, :data, :options, :engine, :repository
+
+      public
+
+      def initialize(name, destination, data, options = {}, engine = ErbGenerator, repository = TemplateRepository.new)
+        @name        = name
+        @destination =::File.expand_path(destination)
+        @data        = data
+        @options     = options
+        @engine      = engine
+        @repository  = repository
+      end
+
+      def run
+        if need_to_run? || options[:force] == true
+          TestServer.ui_logger.warn "Creating file \"#{destination}\"."
+
+          create_directories if options[:create_directories] == true
+
+          file = template(name, ::File.new(destination, 'w'), data)
+          FileUtils.chmod('+x', file) if options[:executable] == true
+        else
+          TestServer.ui_logger.warn "File \"#{destination}\" already exists. Do not create it again!."
+        end
+      end
+
+      private
+
+      def create_directories
+        FileUtils.mkdir_p(::File.dirname(destination))
+      end
+
+      def template(local_name, local_destination, local_data)
+        template = repository.find(local_name)
+
+        generator = engine.new(local_data)
+        generator.compile(template, local_destination)
+
+        local_destination
+      rescue Errno::ENOENT
+        fail Exceptions::ErbTemplateIsUnknown, JSON.dump(message: "Unknown erb template \"#{template_path}\".")
+      end
+
+      def need_to_run?
+        !::File.exists?(destination)
+      end
+    end
+  end
+end

data/lib/test_server/actions/create_output.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module TestServer
+  module Actions
+    class CreateOutput
+      private
+
+      attr_reader :name, :output, :engine, :repository, :data
+
+      public
+
+      def initialize(name, output, data, engine = ErbGenerator, repository = TemplateRepository.new)
+        @name        = name
+        @output      = output
+        @data        = data
+        @engine      = engine
+        @repository  = repository
+      end
+
+      def run
+        TestServer.ui_logger.info "Creating example configuration:"
+        template(name, output, data)
+      end
+
+      private
+
+      def template(local_name, local_destination, local_data)
+        template = repository.find(local_name)
+
+        generator = engine.new(local_data)
+        generator.compile(template, local_destination)
+      rescue Errno::ENOENT
+        fail Exceptions::ErbTemplateIsUnknown, JSON.dump(message: "Unknown erb template \"#{template_path}\".")
+      end
+    end
+  end
+end

data/lib/test_server/actions/handle_error.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module TestServer
+  module Actions
+    class HandleError
+
+      private
+
+      attr_reader :exception, :original_message, :handler_klass, :backtrace
+
+      public
+
+      def initialize(exception, handler_klass = ErrorHandler)
+        @exception        = exception.class
+        @original_message = exception.message
+        @backtrace        = exception.backtrace
+        @handler_klass    = handler_klass
+      end
+
+      def run
+        handler                  = handler_klass.find exception
+        handler.original_message = original_message
+        handler.backtrace        = backtrace
+
+        handler.execute(parsed_message)
+      end
+
+      private
+
+      def parsed_message
+        result = JSON.parse(original_message)
+        return {} unless result.kind_of? Hash
+
+        result
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/test_server/actions/initialize_application.rb

@@ -0,0 +1,56 @@
+module TestServer
+  module Actions
+    class InitializeApplication
+
+      private
+
+      attr_reader :config, :options
+
+      public
+
+      def initialize(options = {}, config = TestServer.config)
+        @options = options
+        @config  = config
+      end
+
+      def run
+        create_pid_directory if options[:create_pid_directory]
+        create_log_directory if options[:create_log_directory]
+        create_sass_cache if options[:create_sass_cache]
+        create_local_storage if options[:create_local_storage]
+        create_pre_receive_hook if options[:create_pre_receive_hook]
+        create_config_file if options[:create_config_file]
+        pre_seed if options[:pre_seed]
+
+        show_example_config
+      end
+
+      private
+
+      def create_pid_directory
+        TestServer.ui_logger.info "Creating pid directory: #{::File.dirname(config.pid_file)}"
+        Actions::CreateDirectory.new(::File.dirname(config.pid_file), force: options[:force]).run
+      end
+
+      def create_log_directory
+        TestServer.ui_logger.info "Creating log directory: #{::File.dirname(config.access_log)}"
+        Actions::CreateDirectory.new(::File.dirname(config.access_log), force: options[:force]).run
+      end
+
+      def create_sass_cache
+        TestServer.ui_logger.info "Creating sass cache #{config.sass_cache}"
+        Actions::CreateDirectory.new(config.sass_cache, force: options[:force]).run
+      end
+
+      def create_config_file
+        TestServer.ui_logger.info "Creating config file at \"#{config.config_file}\"."
+        Actions::CreateFile.new(:'example-config', config.config_file, TestServer::Data.new(config), force: options[:force], create_directories: true).run
+      end
+
+      def show_example_config
+        TestServer.ui_logger.info "Showing the configuration of local_pac on your system."
+        Actions::CreateOutput.new(:'example-config', $stdout, Data.new(config)).run
+      end
+    end
+  end
+end

data/lib/test_server/actions/reload_configuration.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module TestServer
+  module Actions
+    class ReloadConfiguration
+
+      private
+
+      attr_reader :config
+
+      public
+
+      def initialize(config = Config.new)
+        @config = config
+      end
+
+      def run
+        TestServer.config = config
+      end
+    end
+  end
+end

data/lib/test_server/actions/send_signal.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module TestServer
+  module Actions
+    class SendSignal
+      private
+
+      attr_reader :signal, :pid_file, :signalizer
+
+      public
+
+      def initialize(signal, pid_file = TestServer.config.pid_file, signalizer = Process)
+        @signal     = signal
+        @pid_file   = pid_file
+        @signalizer = signalizer
+      end
+
+      def run
+        signalizer.kill signal, pid
+      rescue Exceptions::PidFileDoesNotExist
+        TestServer.ui_logger.error "Pid-file \"#{pid_file}\" does not exist. I'm not able to send daemon signal \"#{signal}\"."
+      end
+
+      private
+
+      def pid
+        ::File.read(pid_file).to_i
+      rescue Errno::ENOENT => e
+        raise Exceptions::PidFileDoesNotExist, e.message
+      end
+    end
+  end
+end

data/lib/test_server/cli/helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module TestServer
+  module Cli
+    module Helper
+      def pid(config = TestServer.config)
+        ::File.read(config.pid_file).chomp
+      rescue Errno::ENOENT
+        'Stale PID-file'
+      end
+    end
+  end
+end

data/lib/test_server/cli/main.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+module TestServer
+  module Cli
+    class Main < Thor
+      class_option :config_file, type: :string, desc: 'Config file'
+      class_option :log_level, default: 'info', type: :string, desc: 'Log level for ui logging'
+      class_option :debug_mode, type: :boolean, desc: 'Run application in debug mode'
+
+      desc 'serve', 'Serve pacfiles'
+      option :access_log, type: :string, desc: 'File to write access log to'
+      option :listen, type: :string, desc: 'Listen for requests'
+      option :environment, type: :string, desc: 'Rack environment for application'
+      option :worker_count, type: :numeric, desc: 'Count of workers'
+      option :with, type: :string, default: 'puma', desc: 'Server used to serve proxy pac'
+      def serve
+        TestServer.config = TestServer::Config.new(options[:config_file]) if options[:config_file]
+        TestServer.config.access_log = options[:access_log] if options[:access_log]
+        TestServer.config.log_level = options[:log_level] if options[:log_level]
+        TestServer.config.debug_mode = options[:debug_mode] if options[:debug_mode]
+        TestServer.config.environment = options[:environment] if options[:environment]
+        TestServer.config.worker_count = options[:worker_count] if options[:worker_count]
+        TestServer.config.listen = options[:listen] if options[:listen]
+        TestServer.config.lock
+
+        TestServer.ui_logger.level = TestServer.config.log_level
+        TestServer.enable_debug_mode if TestServer.config.debug_mode
+
+        TestServer.ui_logger.debug('Options: ' + options.to_s)
+        TestServer.ui_logger.debug("Config:\n" + TestServer.config.to_s)
+
+        command_klass = case options[:with].to_sym
+                 when :puma
+                   ServerCommands::Puma
+                 when :rackup
+                   ServerCommands::Rackup
+                 else
+                   ServerCommands::Rackup
+                 end
+
+        command = command_klass.new(
+          listen: TestServer.config.listen,
+          environment: TestServer.config.environment,
+          worker_count: TestServer.config.worker_count,
+        )
+
+        ENV['DEBUG']      = TestServer.config.debug_mode.to_s if TestServer.config.debug_mode
+        ENV['ACCESS_LOG'] = TestServer.config.access_log.to_s if TestServer.config.access_log
+        ENV['LOG_LEVEL']  = TestServer.config.log_level.to_s  if TestServer.config.log_level
+
+        Server.new(command).start
+      end
+
+      desc 'init', 'Create files/directories to use local_pac in dir or $PWD'
+      option :force, type: :boolean, default: false, desc: 'Overwrite existing files?'
+      option :pre_seed, type: :boolean, default: false, desc: 'Add some example files to git repository'
+      option :config_file, type: :string, desc: 'Path to config file'
+
+      option :pid_file, type: :string, desc: 'Path to pid file'
+      option :access_log, type: :string, desc: 'Path to access log'
+      option :sass_cache, type: :string, desc: 'Path to sass cache'
+      option :reload_config_signal, type: :string, desc: 'Signal to reload config'
+      option :listen, type: :string, desc: 'Listen statement for rack server'
+      option :environment, type: :string, desc: 'Default environment for rack server'
+
+      option :create_pid_directory, type: :boolean, desc: 'Create pid directory', default: true
+      option :create_log_directory, type: :boolean, desc: 'Create log directory', default: true
+      option :create_sass_cache, type: :boolean, desc: 'Create sass cache directory', default: true
+      option :create_config_file, type: :boolean, desc: 'Create config_directory', default: true
+      def init
+        TestServer.config = TestServer::Config.new(options[:config_file]) if options[:config_file]
+
+        TestServer.config.log_level             = options[:log_level]              if options[:log_level]
+        TestServer.config.debug_mode            = options[:debug_mode]             if options[:debug_mode]
+        TestServer.config.pid_file              = options[:pid_file]               if options[:pid_file]
+        TestServer.config.access_log            = options[:access_log]             if options[:access_log]
+        TestServer.config.sass_cache            = options[:sass_cache]             if options[:sass_cache]
+        TestServer.config.reload_config_signal  = options[:reload_config_signal]   if options[:reload_config_signal]
+        TestServer.config.log_level             = options[:log_level]              if options[:log_level]
+        TestServer.config.listen                = options[:listen]                 if options[:listen]
+        TestServer.config.environment           = options[:environment]            if options[:environment]
+
+        TestServer.config.lock
+
+        TestServer.ui_logger.level = TestServer.config.log_level
+        TestServer.enable_debug_mode if TestServer.config.debug_mode
+
+        TestServer.ui_logger.debug('Options: ' + options.to_s)
+        TestServer.ui_logger.debug("Config:\n" + TestServer.config.to_s)
+
+        Actions::InitializeApplication.new(
+          force: options[:force], 
+          pre_seed: options[:pre_seed],
+          create_pid_directory: options[:create_pid_directory],
+          create_log_directory: options[:create_log_directory],
+          create_sass_cache: options[:create_sass_cache],
+          create_config_file: options[:create_config_file],
+        ).run
+      end
+
+      desc 'reload', 'Reload configuration, local storage etc.'
+      option :pid_file, type: :string, desc: 'Pid file of daemon'
+      subcommand 'reload', TestServer::Cli::Reload
+    end
+  end
+end