shellacrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20bc93cc9afb84671752476bcdb5a5ed9714da7b
+  data.tar.gz: bea16b6892d3191b2d584950342497143ccdf220
+SHA512:
+  metadata.gz: 80171b685c351d84e9f592dc34110a865ecc0262eaafbd00f7de1aaaf7fadc1ddbf02c0254aa208141192417a7a2f82bf187606e7877ba58394a02762adf0088
+  data.tar.gz: ce091833fc6f9e7268816500b4cf5a420b97675fe1fe47854db3eaee6cf8a306e97c1123a63bc487657e9d37d0d4319cffb2c3302ce3a117639b6689a143b0e0

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shellac.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Kirk Haines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Kirk Haines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# Shellac
+
+Shellac is a simple caching reverse proxy. In it's current state, it is a
+nominally usable proof of concept. It was built on top of Puma and Rack, and
+it supports pluggable backend storage modules.
+
+## Installation
+
+    $ gem install shellac
+
+## Usage
+
+Use the `-h` flag to get help from `shellac`. If a storage engine is specified
+with `-s`, then any command line flags and arguments supported by that storage
+engine will also be listed.
+
+```
+$ shellac -s hash -h
+shellac [OPTIONS]
+
+shellac is a simple caching proxy server.
+
+-h, --help:
+  Show this help.
+
+-b HOSTNAME[:PORT], --bind HOSTNAME[:PORT]:
+  The hostname/IP and optionally the port to bind to. This defaults to 127.0.0.1:80 if it is not provided.
+
+-c FILENAME, --config FILENAME:
+  The configuration file to load.
+
+-r ROUTESPEC, --route ROUTESPEC:
+  Provides a routing specification for the proxy. A route spec is one or more
+  host names or IPs, comma seperated, to match requests from, a regular
+  expression to match against, and a target to proxy to:
+
+  -r 'foo.bar.com::\?(w+)$::https://github.com/'
+
+  This can be specified multiple times. For complex route specs, it is better
+  to use a configuration file.
+
+-s ENGINE, --storageengine ENGINE:
+  The storage engine to use for storing cached content.
+
+-t MIN:MAX, --threads MIN:MAX:
+  The minimum and maximum number of threads to run. Defaults to 0:10
+
+-w COUNT, --workers COUNT:
+  The number of worker processes to start.
+
+-v, --version:
+  Show the version of shellac.
+
+--cache-trim-interval INTERVAL:
+  The wait time in seconds between sweeps of the cache to ensure it isn't too large.
+
+--max-cache-elements LENGTH:
+  The maximum number of elements to store in the cache.
+
+--max-cache-size SIZE:
+  The maximum size, in bytes, of the cache.
+
+```
+
+For simple usage, routing rules can be specified right on the command line.
+They are given in the format of:
+
+```
+DOMAIN[,DOMAIN2,DOMAINn]::MATCHRULE::DESTINATION
+```
+
+The DOMAIN section is a comma delimited list of one or more host names or IPs
+which will match this rule.
+
+THe MATCHRULE itself is simply a regular expression. The first rule that
+matches stops checking of any remaining rules.
+
+The DESTINATION can be either a simple string which will be evaulated with
+normal Ruby string interpolation rules, allowing matched portions of the
+MATCHRULE to be inserted, or it can be a chunk of ruby code to execute, the
+return value of which should be a URL to proxy to.
+
+If providing actual Ruby code, the `DESTINATION` should be prefixed with
+`lambda:`. It is suggested that if a DESTINATION is to be determined by any
+non-trivial code, that a configuration file be used instead of a command line
+argument.
+
+An example:
+
+```
+shellac -s hash -r '127.0.0.1::\?(.*)$::https://github.com/#{$1}' -t 2:16 -w 1
+```
+
+This will use the built in Ruby in memory Hash based storage engine (which is
+also the default if `-s` is not specified. It is looking for requests on the
+localhost IP, with a query string specified. If it finds a match, it uses the
+query string to construct a github.com URL, and proxies that. It will run with
+a minimum of two, and a maximum of 16 threads, and with a single worker
+process.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+ prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/wyhaines/shellac.
+
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "shellac"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/shellac

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'shellac'
+
+puts "Leftover: #{ARGV.inspect}"
+
+Shellac::Launcher.run

data/lib/shellac/application.rb

@@ -0,0 +1,85 @@
+module Shellac
+  class Launcher
+    class << self
+      def run
+        puma_config = Puma::Configuration.new do |pconf|
+          pconf.threads Config[:minimum_threads], Config[:maximum_threads]
+          pconf.workers Config[:worker_count]
+          Config[:bind].each {|b| pconf.bind b}
+          pconf.app Application
+        end
+
+        Puma::Launcher.new(puma_config, events: Puma::Events.stdio).run
+      end
+    end
+  end
+
+  class ApplicationHelpers
+    class << self
+      def run
+        puma_config = Puma::Configuration.new do |pconf|
+          pconf.threads Config[:minimum_threads], Config[:maximum_threads]
+          pconf.workers Config[:worker_count]
+          pconf.app Application
+        end
+      end
+
+      def request_headers( env )
+        Hash[*env.select {|k,v| k.start_with? 'HTTP_'}
+          .collect {|k,v| [k.sub(/^HTTP_/, ''), v]}
+          .collect {|k,v| [k.split('_').collect(&:capitalize).join('-'), v]}
+          .flatten]
+      end
+    end
+  end
+
+  Application = lambda { |env|
+    hdrs = Shellac::ApplicationHelpers.request_headers( env )
+    hdrs.delete("Host")
+    response = nil
+
+    original_url = ::Rack::Request.new( env ).url
+
+    if Shellac::Config[:routes].has_key?( env["SERVER_NAME"] )
+      Shellac::Config[:routes][ env["SERVER_NAME"] ].each do |route|
+        if cached_response = Shellac::Config[:storageengine]["response:#{original_url}"]
+          response = cached_response
+        elsif to_url = route[:func].call(original_url, route[:regexp])
+          fetched_response = HTTP.request(
+            env["REQUEST_METHOD"].downcase.intern,
+            to_url,
+            HTTP.default_options.with_headers( hdrs )
+          )
+          fetched_body = fetched_response.body
+          body = []
+          if fetched_response.chunked?
+            while partial = fetched_body.readpartial
+              body << ( partial.bytesize.to_s(16) << "\r\n" << partial << "\r\n")
+            end
+            body << "0\r\n\r\n"
+          else
+            while partial = fetched_body.readpartial
+              body << partial
+            end
+          end
+          # Make this sexy and make it so that the exact caching key can be
+          # specified instead of just crude path based caching.
+
+          response = [
+            fetched_response.status.code,
+            fetched_response.headers.to_h,
+            body
+          ]
+          Shellac::Config[:storageengine]["response:#{original_url}"] = response
+          break
+        end
+      end
+    end
+
+    if response
+      response
+    else
+      [200, {}, ["undefined"]]
+    end
+  }
+end

data/lib/shellac/config/task.rb

@@ -0,0 +1,35 @@
+module Shellac
+  class ConfigClass
+    class Task
+      include Comparable
+
+      attr_accessor :order, :task
+
+      def initialize(order = 0, &task)
+        @order = order
+        @task = task
+      end
+
+      def <=>(another_task)
+        if @order < another_task.order
+          -1
+        elsif @order > another_task.order
+          1
+        else
+          if @task.to_s < another_task.task.to_s
+            -1
+          elsif @task.to_s > another_task.task.to_s
+            1
+          else
+            0
+          end
+        end
+      end
+
+      def call(*args)
+        @task.call(*args) if @task
+      end
+
+    end
+  end
+end

data/lib/shellac/config/tasklist.rb

@@ -0,0 +1,6 @@
+module Shellac
+  class ConfigClass
+    class TaskList < Array
+    end
+  end
+end

data/lib/shellac/config.rb

@@ -0,0 +1,241 @@
+require 'optparse'
+require 'shellac/storage_engine'
+require 'shellac/config/task'
+require 'shellac/config/tasklist'
+
+module Shellac
+  class ConfigClass
+    def initialize
+      @configuration = {}
+      @configuration[:bind] = []
+      @configuration[:minimum_threads] = 1
+      @configuration[:maximum_threads] = 10
+      @configuration[:worker_count] = 1
+      @configuration[:routes] = Hash.new { |h, k| h[k] = [] }
+
+      @meta_configuration = {}
+      @meta_configuration[:helptext] = ''
+    end
+
+    def [](val)
+      @configuration.has_key?(val) ? @configuration[val] : @meta_configuration[val]
+    end
+
+    def config
+      @configuration
+    end
+
+    def meta
+      @meta_configuration
+    end
+
+    def parse(parse_cl = true, additional_config = {}, additional_meta_config = {}, additional_tasks = nil)
+      @configuration.merge! additional_config
+      @meta_configuration.merge! additional_meta_config
+
+      tasklist = parse_command_line if parse_cl
+
+      tasklist = merge_task_lists(tasklist, additional_tasks) if additional_tasks
+
+      run_task_list tasklist
+    end
+
+    def run_task_list( tasks )
+      tasks = tasks.sort
+
+      result = nil
+      while tasks.any? do
+        new_task = tasks.shift
+        result = new_task.call # If any task returns a task list, fall out of execution
+        break if TaskList === result
+      end
+
+      tasks = merge_task_lists(tasks, result) if TaskList === result # merge any new tasks into the remaining tasks
+
+      run_task_list( tasks ) if tasks.any? # run any remaining tasks
+    end
+
+    def merge_task_lists(old_list, new_list)
+      ( old_list + new_list ).sort
+    end
+
+    def parse_command_line
+      call_list = TaskList.new
+
+      options = OptionParser.new do |opts|
+        opts.on( '-h', '--help' ) do
+          exe = File.basename( $PROGRAM_NAME )
+          @meta_configuration[:helptext] << <<-EHELP
+#{exe} [OPTIONS]
+
+#{exe} is a simple caching proxy server.
+
+-h, --help:
+  Show this help.
+
+-b HOSTNAME[:PORT], --bind HOSTNAME[:PORT]:
+  The hostname/IP and optionally the port to bind to. This defaults to 127.0.0.1:80 if it is not provided.
+
+-c FILENAME, --config FILENAME:
+  The configuration file to load.
+
+-r ROUTESPEC, --route ROUTESPEC:
+  Provides a routing specification for the proxy. A route spec is one or more
+  host names or IPs, comma seperated, to match requests from, a regular
+  expression to match against, and a target to proxy to:
+
+  -r 'foo.bar.com::\?(\w+)$::https://github.com/\#{$1}'
+
+  This can be specified multiple times. For complex route specs, it is better
+  to use a configuration file.
+
+-s ENGINE, --storageengine ENGINE:
+  The storage engine to use for storing cached content.
+
+-t MIN:MAX, --threads MIN:MAX:
+  The minimum and maximum number of threads to run. Defaults to 0:10
+
+-w COUNT, --workers COUNT:
+  The number of worker processes to start.
+
+-v, --version:
+  Show the version of #{exe}.
+EHELP
+          call_list << Task.new(9999) { puts @meta_configuration[:helptext]; exit 0 }
+        end
+
+        opts.on( '-v', '--version') do
+          exe = File.basename( $PROGRAM_NAME )
+          @meta_configuration[:version] = "#{exe} v. #{Shellac::VERSION}"
+          call_list << Task.new(9999) { puts @meta_configuration[:version]; exit 0 }
+        end
+
+        opts.on( '-c', '--config FILENAME' ) do |configfile|
+          require 'yaml'
+          call_list << Task.new(0) do
+            parsed_config = YAML.load( File.read( File.expand_path( configfile ) ) )
+            @configuration = parsed_config.merge( @configuration ) if Hash === parsed_config
+          end
+        end
+
+        opts.on( '-s', '--storageengine ENGINE' ) do |storageengine|
+          @configuration[:storageengine] = storageengine
+          call_list << Task.new(1) do
+            libname = "shellac/storage_engine/#{@configuration[:storageengine]}"
+            setup_engine(:storageengine, libname)
+          end
+        end
+
+        opts.on( '-t', '--threads THREADSPEC' ) do |threadspec|
+          call_list << Task.new(9000) do
+            min = 1
+            max = 10
+            if threadspec =~ /\s*(\d+)\s*:\s*(\d+)/
+              min,max = [ $1.to_i > 0 ? $1.to_i : 1, $2.to_i > 0 ? $2.to_i : 10 ]
+            else
+              n = Integer( threadspec.to_i )
+              max = n > 0 ? n : 10
+            end
+            @configuration[:minimum_threads] = min
+            @configuration[:maximum_threads] = max
+          end
+        end
+
+        opts.on( '-w', '--workers COUNT' ) do |worker_count|
+          call_list << Task.new(9000) do
+            count = Integer( worker_count.to_i )
+            count = count > 0 ? count : 1
+            @configuration[:worker_count] = count
+          end
+        end
+
+        opts.on( '-r', '--route ROUTESPEC' ) do |routespec|
+          # -r 'foo.bar.com::?(\w+)::https://github.com/#{$1}'
+          #
+          hosts,regexp,matchfunc = routespec.split(/::/,3)
+
+          hosts = hosts.split(/,/).collect {|h| h.strip}
+
+          regexp = Regexp.new( regexp )
+
+          if matchfunc =~ /^lambda:(.*)$/m
+            code = "#{$1}"
+          else
+            code = "\"#{matchfunc}\""
+          end
+
+          matchfunc = <<~ECODE
+  lambda {|s,r|
+    if s =~ r
+      #{code}
+    else
+      nil
+    end
+  }
+  ECODE
+          matchfunc = Object.new.instance_eval(matchfunc)
+
+          hosts.each do |h|
+            @configuration[:routes][h] << {
+              regexp: regexp,
+              func: matchfunc
+            }
+          end
+        end
+
+       opts.on( '-b', '--bind HOST') do |host_and_port|
+          if host_and_port =~ /^(\w+:\/\/)/ 
+            protocol = $1
+            host_and_port.gsub!(/^\w+:\/\//,'')
+          else
+            protocol = 'tcp://'
+          end
+          h,p = host_and_port.split(/:/,2)
+          h = '127.0.0.1' if h.empty?
+          p = '80' if p.empty?
+          call_list << Task.new(9000) { @configuration[:bind] << "#{protocol}#{h}:#{p}" }
+        end
+      end
+
+      leftover_argv = []
+
+      begin
+        options.parse!(ARGV)
+      rescue OptionParser::InvalidOption => e
+        e.recover ARGV
+        leftover_argv << ARGV.shift
+        leftover_argv << ARGV.shift if ARGV.any? && ( ARGV.first[0..0] != '-' )
+        retry
+      ensure
+        puts "adding default storage engine"
+        unless @configuration[:storageengine]
+          @configuration[:storageengine] = 'hash'
+          call_list << Task.new(100) do
+            libname = "shellac/storage_engine/#{@configuration[:storageengine]}"
+            setup_engine(:storageengine, libname)
+          end
+        end
+      end
+
+      ARGV.replace( leftover_argv ) if leftover_argv.any?
+
+      call_list
+    end
+
+    def classname(klass)
+      parts = Array === klass ? klass : klass.split(/::/)
+      parts.inject(::Object) {|o,n| o.const_get n}
+    end
+
+    def setup_engine(key, libname)
+      require libname
+      klass = classname( libname.split(/\//).collect {|s| s.capitalize} )
+      @configuration[key] = klass.new
+      @configuration[key].class.parse_command_line(@configuration, @meta_configuration) if @configuration[key].class.respond_to? :parse_command_line
+    end
+
+  end
+
+  Config = ConfigClass.new
+  Config.parse
+end

data/lib/shellac/core.rb

@@ -0,0 +1,6 @@
+require 'http'
+require 'puma/cli'
+require 'rack'
+require 'shellac/version'
+require 'shellac/application'
+require 'shellac/config'

data/lib/shellac/storage_engine/hash.rb

@@ -0,0 +1,64 @@
+require 'shellac/storage_engine'
+
+module Shellac
+  class Storage_engine
+    class Hash < Shellac::Storage_engine::Base
+
+      def self.parse_command_line(configuration, meta_configuration)
+        call_list = Shellac::ConfigClass::TaskList.new
+
+        meta_configuration[:helptext] << <<-EHELP
+
+--cache-trim-interval INTERVAL:
+  The wait time in seconds between sweeps of the cache to ensure it isn't too large.
+
+--max-cache-elements LENGTH:
+  The maximum number of elements to store in the cache.
+
+--max-cache-size SIZE:
+  The maximum size, in bytes, of the cache.
+
+EHELP
+
+        options = OptionParser.new do |opts|
+          opts.on( '--cache-trim-interval INTERVAL' ) do |interval|
+            call_list << Shellac::ConfigClass::Task.new(9000) do
+              n = Integer( interval.to_i )
+              configuration[:cache_trim_interval] = n
+            end
+          end
+
+          opts.on( '--max-cache-elements LENGTH' ) do |len|
+            call_list << Shellac::ConfigClass::Task.new(9000) do
+              n = Integer( len.to_i )
+              configuration[:cache_max_elements] = n
+            end
+          end
+
+          opts.on( '--max-cache-size SIZE' ) do |size|
+            call_list << Shellac::ConfigClass::Task.new(9000) do
+              n = Integer( size.to_i )
+              n = n > 0 ? n : 1024 * 1024 * 20
+              configuration[:cache_max_size] = n
+            end
+          end
+        end
+
+        leftover_argv = []
+
+        begin
+          options.parse!(ARGV)
+        rescue OptionParser::InvalidOption => e
+          e.recover ARGV
+          leftover_argv << ARGV.shift
+          leftover_argv << ARGV.shift if ARGV.any? && ( ARGV.first[0..0] != '-' )
+          retry
+        end
+
+        ARGV.replace( leftover_argv ) if leftover_argv.any?
+
+        call_list
+      end
+    end
+  end
+end

data/lib/shellac/storage_engine/roma.rb

@@ -0,0 +1,54 @@
+module Shellac
+  class StorageEngine
+    class Roma << Shellac::StorageEngine
+      def self.parse_command_line(configuration, meta_configuration)
+        call_list = Shellac::Config::TaskList.new
+
+        meta_configuration[:helptext] << <<-EHELP
+--processes COUNT:
+  The number of processes to fork. Defaults to 1.
+
+-s SIZE|MINSIZE,MAXSIZE, --pool-size SIZE|MINSIZE,MAXSIZE:
+  The size of the thread pool to create. If unset, Scrawls will spawn a thread for each request. If given two comman separated numbers, those numbers will be interpreted to be the minimum and maximum size of the thread pool. Scrawls will spawn new threads as needed, to the maximum number, if all threads are busy, and will later reduce the size of the thread pool back down toward the minimum size if the threads become idle.
+
+EHELP
+
+        options = OptionParser.new do |opts|
+          opts.on( '--processes COUNT' ) do |count|
+            call_list << SimpleRubyWebServer::Config::Task.new(9000) { n = Integer( count.to_i ); n = n > 0 ? n : 1; configuration[:processes] = n }
+          end
+
+          opts.on( '--s', '--pool-size SIZE' ) do |size|
+            call_list << SimpleRubyWebServer::Config::Task.new(9000) do
+              n = nil
+
+              if size =~ /\s*(\d+)\s*,\s*(\d+)/
+                n = [ $1.to_i, $2.to_i > 0 ? $2.to_i : 1 ]
+              else
+                n = Integer( size.to_i )
+                n = n > 0 ? [ n ] : nil
+              end
+
+              configuration[:thread_pool] = n
+            end
+          end
+        end
+
+        leftover_argv = []
+
+        begin
+          options.parse!(ARGV)
+        rescue OptionParser::InvalidOption => e
+          e.recover ARGV
+          leftover_argv << ARGV.shift
+          leftover_argv << ARGV.shift if ARGV.any? && ( ARGV.first[0..0] != '-' )
+          retry
+        end
+
+        ARGV.replace( leftover_argv ) if leftover_argv.any?
+
+        call_list
+      end
+    end
+  end
+end

data/lib/shellac/storage_engine.rb

@@ -0,0 +1,65 @@
+module Shellac
+  class Storage_engine
+    class Base
+      def initialize( args = {} )
+        @config = _default_args.merge( args )
+        @cache_control_thread = new_cache_control_thread
+        @cache_size = 0
+        @cache = {}
+      end
+
+      def _default_args
+        {
+          preload: {},
+          length_limit: 1000,
+          size_limit: 1024 * 1024 * 20,
+          trim_interval: 30 
+        }
+      end
+
+      def new_cache_control_thread
+        Thread.new do
+          sleep( @config[ :trim_interval ] )
+
+          while @cache_size > @config[ :size_limit ]
+            # Trim Cache -- stupid algorithm just randomly deletes things
+            # until it is small enough
+            sz = @cache.delete( @cache.keys[ rand( @cache.length ) ] ).to_s.length
+            @cache_size -= sz
+          end
+        end
+      end
+
+      def []( k )
+        @cache[ k ]
+      end
+
+      def get( k )
+        self[ k ]
+      end
+
+      def []=( k, v )
+        @cache_size += v.to_s.length
+        @cache[ k ] = v
+      end
+
+      def set( k, v )
+        self[ k ] = v
+      end
+
+      def keys
+        @cache.keys
+      end
+
+      def delete( k )
+        @cache.delete( k )
+      end
+
+      def length
+        @cache.length
+      end
+      alias_method :size, :length
+
+    end
+  end
+end

data/lib/shellac/version.rb

@@ -0,0 +1,3 @@
+module Shellac
+  VERSION = "0.1.0"
+end

data/lib/shellac.rb

@@ -0,0 +1,4 @@
+require 'shellac/core'
+
+module Shellac
+end

data/shellacrb.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shellac/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shellacrb"
+  spec.version       = Shellac::VERSION
+  spec.authors       = ["Kirk Haines"]
+  spec.email         = ["kirk-haines@cookpad.com"]
+
+  spec.summary       = %q{A simple caching proxy, written in Ruby.}
+  spec.description   = %q{A simple caching proxy, like Varnish, but...not. And written in Ruby.}
+  spec.homepage      = "https://github.com/wyhaines/shellac"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+
+  spec.add_runtime_dependency "puma", "~> 3.11"
+  spec.add_runtime_dependency "http", "~> 3.3"
+  spec.add_runtime_dependency "rack", "~> 2.0"
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: shellacrb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kirk Haines
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A simple caching proxy, like Varnish, but...not. And written in Ruby.
+email:
+- kirk-haines@cookpad.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/shellac
+- lib/shellac.rb
+- lib/shellac/application.rb
+- lib/shellac/config.rb
+- lib/shellac/config/task.rb
+- lib/shellac/config/tasklist.rb
+- lib/shellac/core.rb
+- lib/shellac/storage_engine.rb
+- lib/shellac/storage_engine/hash.rb
+- lib/shellac/storage_engine/roma.rb
+- lib/shellac/version.rb
+- shellacrb.gemspec
+homepage: https://github.com/wyhaines/shellac
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: A simple caching proxy, written in Ruby.
+test_files: []