iodine 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51d03f6b35a78289c742fbed134a68963bc5ddd6
-  data.tar.gz: 8d541074dd1f8fbde916034e659b28816417e863
+  metadata.gz: 4562f69fd3e73d156c4007d70400f07973c143ea
+  data.tar.gz: 14264f438e3e200ad52f18f63881087854da88b1
 SHA512:
-  metadata.gz: 3365f3efe45797ab9fef24fd61e003425debbc680dc190ca14ffc7797fda812e520c1849a95232f199e3a50b220d04f37e8e922d8a72a8cc65bc1eaa605cfec7
-  data.tar.gz: 3cb5df7d237484fe18fd8828f33a682d210339821322b7c2e709a826bde3cb66c9e0d638a5843b46e28fbab56cf09a0203bed7848ec3383174d3399ab2190c8f
+  metadata.gz: ab840a1c507e08b328b257e42038ec1dad3eaaaaad8703b1d0d1085707a20dddfb21b7e290eeec80008eb49c8beb8eb94901a17e0c9efa5648a9107c1d36d943
+  data.tar.gz: e4f5a83897e9bf8eb33225278010abc1be7bb0787eeec3eed77704b7f2f383448becad6c0b870988c77aecec5e3edba1248b1c46765376bff07cfc3f2ba9a406

data/README.md

@@ -1,12 +1,10 @@
 # Iodine
 
-Iodine makes writing evented server applications easy to write.
+Iodine makes writing Object Oriented evented server applications easy to write.
 
-Iodine is intended to replace the use of a generic reacor, such as EventMachine or GReactor and it hides all the nasty details of creating the event loop.
+In fact, it's so fun to write network protocols that mix and match together, that Iodine includes a built in Http, Http/2 (experimental) and Websocket server that act's a a great demonstration of the power behind Ruby and the Object Oriented approach.
 
-To use Iodine, you just set up your tasks - including a single server, if you want one. Iodine will start running once your application is finished and it won't stop runing until all the tasks have completed.
-
-Iodine v. 0.0.1 isn't well tested just yet... but I'm releasing it anyway, to reserve the name and because initial testing shows that it works.
+To use Iodine, you just set up your tasks - including a single server, if you want one. Iodine will start running once your application is finished and it won't stop runing until all the scheduled tasks have completed.
 
 ## Installation
 
@@ -24,9 +22,11 @@ Or install it yourself as:
 
     $ gem install iodine
 
-## Simple Usage
+## Simple Usage: Running tasks and shutting down
+
+This mode of operation is effective if you have a `cron`-job that periodically initiates an Iodine Ruby script. It allows the script to easily initiate a task's stack and perform the tasks concurrently.
 
-Iodine starts to work once you app is finished with setting all the tasks up (upon exit).
+Iodine starts to work once you app is finished setting all the tasks up (upon exit).
 
 To see how that works, open your `irb` terminal an try this:
 
@@ -52,12 +52,90 @@ Iodine.threads = 5
 exit
 ```
 
-## Server Usage
+In this mode, Iodine will continue running until all the tasks have completed and than it will quite. Timer based tasks will be ignored.
+
+## Simple Usage: Task polling (unreleased version)
+
+This mode of operation is effective if want Iodine to periodically initiates new tasks, for instance if you cannot use `cron`.
+
+To initiate this mode, simply set: `Iodine.protocol = :timers`
+
+In example:
+
+```ruby
+require 'iodine'
+
+# set concurrency level (defaults to a single thread).
+Iodine.threads = 5
+
+# set Iodine to keep listening to TimedEvent(s).
+Iodine.protocol = :timers
+
+# perform a periodical task every ten seconds
+Iodine.run_every 10 do
+   Iodine.run { sleep 5; puts " * this could have been a long task..." }
+   puts "I could be polling a database to schedule more tasks..."
+end
+
+# Iodine will start running once your script is done and it will never stop unless stopped.
+exit
+```
+
+In this mode, Iodine will continue running until it receives a kill signal (i.e. `^C`). Once the kill signal had been received, Iodine will start shutting down, allowing up to ~20-25 seconds to complete any pending tasks (timeout).
+
+## Server Usage: an Http and Websocket (as well as Rack) server
+
+
+
+## Server Usage: Plug in your network protocol
 
 Iodine is designed to help write network services (Servers) where each script is intended to implement a single server.
 
 This is not a philosophy based on any idea or preferences, but rather a response to real-world design where each Ruby script is usually assigned a single port for network access (hence, a single server).
 
+To help you write your network service, Iodine starts you off with the `Iodine::Protocol`. All network protocols should inherit from this class (or implement it's essencial functionality).
+
+Here's a quick Echo server:
+
+```ruby
+require 'iodine'
+
+# inherit from ::Iodine::Protocol
+class EchoServer < Iodine::Protocol
+    # The protocol class will call this withing a Mutex,
+    # making sure the IO isn't accessed while being initialized.
+	def on_open
+		Iodine.info "Opened connection."
+		set_timeout 5
+	end
+    # The protocol class will call this withing a Mutex, after reading the data from the IO.
+    # This makes this thread-safe per connection.
+	def on_message data
+		write("-- Closing connection, goodbye.\n") && close if data =~ /^(bye|close|exit|stop)/i
+		write(">> #{data.chomp}\n")
+	end
+	# Iodine makes sure this is called only once.
+	def on_close
+		Iodine.info "Closed connection."
+	end
+	# The is called whenever timeout is reached.
+	# By default, ping will close the connection.
+	# but we can do better...
+	def ping
+	    # `write` will automatically close the connection if it fails.
+		write "-- Are you still there?\n"
+	end
+end
+
+
+Iodine.protocol = EchoServer
+
+# if running this code within irb:
+exit
+```
+
+In this mode, Iodine will continue running until it receives a kill signal (i.e. `^C`). Once the kill signal had been received, Iodine will start shutting down, allowing up to ~20-25 seconds to complete any pending tasks (timeout).
+
 ## 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.

data/lib/iodine.rb

@@ -1,7 +1,48 @@
-require "logger"
+require 'logger'
 require 'socket'
+require 'openssl'
+# require 'securerandom'
 
 
+# Iodine is an easy Object-Oriented library for writing network applications (servers) with your own
+# network protocol.
+#
+# Please read the {file:README.md} file for an introduction to Iodine.
+#
+# Here's a quick and easy echo server,
+# notice how Iodine will automatically start running once you finish setting everything up:
+#
+#       require 'iodine'
+#
+#       class MyProtocol < Iodine::Protocol
+#          # Iodine will call this whenever a new connection is opened.
+#          def on_open
+#             # Iodine includes logging as well as unique assigned instance ID's.
+#             Iodine.info "New connection id: #{id}"
+#             # Iodine includes timeout support with automatic pinging or connection termination.
+#             set_timeout 5
+#          end
+#          def on_message data
+#             write("-- Closing connection, goodbye.\n") && close if data =~ /^(bye|close|exit)/i
+#             write(">> #{data.chomp}\n")
+#          end
+#          # Iodine will call this whenever a new connection is closed.
+#          def on_close
+#             Iodine.info "Closing connection id: #{id}"
+#          end
+#          # Iodine will call this whenever a a timeout is reached.
+#          def ping
+#             # If `write` fails, it automatically closes the connection.
+#             write("-- Are you still there?\n")
+#          end
+#       end
+#
+#       # setting up the server is as easy as plugging in your Protocol class:
+#       Iodine.protocol = MyProtocol
+#       
+#       # if you are excecuting this script from IRB, exit IRB to start Iodine.
+#       exit
+#
 module Iodine
   extend self
 end
@@ -13,5 +54,7 @@ require "iodine/logging"
 require "iodine/core"
 require "iodine/timers"
 require "iodine/protocol"
-require "iodine/ssl_protocol"
+require "iodine/ssl_connector"
 require "iodine/io"
+
+# require 'iodine/http'

data/lib/iodine/core.rb

@@ -8,47 +8,18 @@ module Iodine
 	#
 	# use:
 	#
-	#      GReactor.run_async(arg1, arg2, arg3 ...) { |arg1, arg2, arg3...| do_something }
+	#      Iodine.run(arg1, arg2, arg3 ...) { |arg1, arg2, arg3...| do_something }
 	#
 	# the block will be run within the current context, allowing access to current methods and variables.
 	#
-	# @return [GReactor] always returns the reactor object.
+	# @return [Iodine] always returns the reactor object.
 	def run *args, &block
-		queue block, args
-	end
-	alias :run_async :run
-
-	# This method runs an object's method asynchronously and returns immediately. This method will also run an optional callback if a block is supplied.
-	#
-	# This method accepts:
-	# object:: an object who's method will be called.
-	# method:: the method's name to be called. type: Symbol.
-	# *args:: any arguments to be passed to the method.
-	# block (optional):: If a block is supplied, it will be used as a callback and the method's return value will be passed on to the block.
-	#
-	# @return [GReactor] always returns the reactor object.
-	def callback object, method_name, *args, &block
-		block ? queue(@callback_proc, [object.method(method_name), args, block]) : queue(object.method(method_name), args)
-	end
-
-	# Adds a job OR a block to the queue. {GReactor.run_async} and {GReactor.callback} extend this core method.
-	#
-	# This method accepts two possible arguments:
-	# job:: An object that answers to `call`, usually a Proc or Lambda.
-	# args:: (optional) An Array of arguments to be passed on to the executed method.
-	#
-	# @return [GReactor] always returns the reactor object.
-	#
-	# The callback will NOT be called if the executed job failed (raised an exception).
-	# @see .run_async
-	#
-	# @see .callback
-	def queue job, args = nil
-		@queue << [job, args]
+		@queue << [block, args]
 		self
 	end
+	alias :run_async :run
 
-	# Adds a shutdown tasks. These tasks should be executed in order of creation.
+	# @return [Iodine] Adds a shutdown tasks. These tasks should be executed in order of creation.
 	def on_shutdown *args, &block
 		@shutdown_queue << [block, args]
 		self
@@ -61,7 +32,7 @@ module Iodine
 	@stop = true
 	@done = false
 	@logger = Logger.new(STDOUT)
-	@thread_count = 1
+	@spawn_count = @thread_count = 1
 	@ios = {}
 	@io_in = Queue.new
 	@io_out = Queue.new
@@ -92,14 +63,15 @@ module Iodine
 		@thread_count.times { threads << Thread.new {  cycle } }
 		unless @stop
 			catch(:stop) { sleep }
-			@logger << "\nShutting down Iodine. Setting shutdown timeout to 30 seconds.\n"
+			@logger << "\nShutting down Iodine. Setting shutdown timeout to 25 seconds.\n"
 			@stop = true
 			# setup exit timeout.
-			threads.each {|t| Thread.new {sleep 30; t.kill; t.kill } }
+			threads.each {|t| Thread.new {sleep 25; t.kill; t.kill } }
 		end
 		threads.each {|t| t.join rescue true }
 	end
 
+	# performed once - the shutdown sequence.
 	def shutdown
 		return if @done
 		@stop = @done = true

data/lib/iodine/http.rb

@@ -0,0 +1,135 @@
+require 'iodine'
+require 'stringio'
+require 'time'
+require 'json'
+require 'yaml'
+require 'uri'
+require 'tmpdir'
+require 'zlib'
+require 'securerandom'
+
+require 'iodine/http/request'
+require 'iodine/http/response'
+require 'iodine/http/session'
+
+require 'iodine/http/http1'
+
+require 'iodine/http/hpack'
+require 'iodine/http/http2'
+
+require 'iodine/http/websockets'
+# require 'iodine/http/websockets_handler'
+require 'iodine/http/websocket_client'
+
+require 'iodine/http/rack_support'
+
+
+module Iodine
+
+	# The {Iodine::Http} class allows the creation of Http and Websocket servers using Iodine.
+	#
+	# To start an Http server, simply require `iodine/http` (which isn't required by default) and set up
+	# your Http callback. i.e.:
+	#
+	#       require 'iodine/http'
+	#       Iodine::Http.on_http { |request, response| 'Hello World!' }
+	#
+	# To start a Websocket server, require `iodine/http` (which isn't required by default), create a Websocket handling Class and set up
+	# your Websocket callback. i.e.:
+	#
+	#       require 'iodine/http'
+	#       class WSChatServer
+	#          def initialize nickname
+	#              @nickname = nickname || "unknown"
+	#          end
+	#          def on_open protocol
+	#              @io = protocol
+	#              @io.broadcast "#{@nickname} has joined the chat!"
+	#              @io << "Welcome #{@nickname}, you have joined the chat!"
+	#          end
+	#          def on_message data
+	#              @io.broadcast "#{@nickname} >> #{data}"
+	#              @io << ">> #{data}"
+	#          end
+	#          def on_broadcast data
+	#              @io << data
+	#          end
+	#          def on_close
+	#              @io.broadcast "#{@nickname} has left the chat!"
+	#          end
+	#       end
+	#
+	#       Iodine::Http.on_websocket { |request, response| WSChatServer.new request.params[:name]}
+	#
+	class Http < Iodine::Protocol
+		# Sets or gets the Http callback.
+		#
+		# An Http callback is a Proc like object that answers to `call(request, response)` and returns either:
+		# `true`:: the response has been set by the callback and can be managed (including any streaming) by the server.
+		# `false`:: the request shouldn't be answered or resource not found (error 404 will be sent as a response).
+		# String:: the String will be appended to the response and the response sent.
+		def self.on_http handler = nil, &block
+			@http_app = handler || block if handler || block
+			@http_app
+		end
+		# Sets or gets the Websockets callback.
+		#
+		# A Websockets callback is a Proc like object that answers to `call(request)` and returns either:
+		# `false`:: the request shouldn't be answered or resource not found (error 404 will be sent as a response).
+		# Websocket Handler:: a Websocket handler is an object that is expected to answer `on_message(data)` and `on_close`. See {} for more data.
+		def self.on_websocket handler = nil, &block
+			@websocket_app = handler || block if handler || block
+			@websocket_app
+		end
+
+		# Sets the session token for the Http server (String). Defaults to the name of the script + '_id'.
+		def self.session_token= token
+			@session_token = token
+		end
+		# Sets the session token for the Http server (String). Defaults to the name of the script.
+		def self.session_token
+			@session_token
+		end
+
+		# Creates a websocket client within a new task (non-blocking).
+		# 
+		# Make sure to setup all the callbacks (as needed) prior to starting the connection. See {::Iodine::Http::WebsocketClient.connect}
+		#
+		# i.e.:
+		#
+		#       require 'iodine/http'
+		#       options = {}
+		#       options[:on_open] = Proc.new { write "Hello there!"}
+		#       options[:on_message] = Proc.new do |data|
+		#           puts ">> #{data}";
+		#           write "Bye!";
+		#           # It's possible to update the callback midstream.
+		#           on_message {|data| puts "-- Goodbye message: #{data}"; close}
+		#       end
+		#       options[:on_close] = Proc.new { puts "disconnected"}
+		#       
+		#       Iodine::Http.ws_connect "ws://echo.websocket.org", options
+		#     
+		def self.ws_connect url, options={}, &block
+			::Iodine.run { ::Iodine::Http::WebsocketClient.connect url, options, &block }
+		end
+
+		@websocket_app = @http_app = NOT_IMPLEMENTED = Proc.new { |i,o| false }
+		@session_token = "#{File.basename($0, '.*')}_uuid"
+	end
+
+	@queue.tap do |q|
+		arr =[];
+		arr << q.pop until q.empty?;
+		run { Iodine.ssl_protocols = { 'h2' => Iodine::Http::Http2, 'http/1.1' => Iodine::Http } if @ssl && @ssl_protocols.empty? }
+		run do
+			if Iodine.protocol == ::Iodine::Http && ::Iodine::Http.on_http == ::Iodine::Http::NOT_IMPLEMENTED && ::Iodine::Http.on_websocket == ::Iodine::Http::NOT_IMPLEMENTED
+				::Iodine.protocol = :http_not_initialized
+				q << arr.shift until arr.empty?
+				run { Process.kill("INT", 0) }
+			end
+		end
+		q << arr.shift until arr.empty?
+	end
+end
+Iodine.protocol = ::Iodine::Http

data/lib/iodine/http/hpack.rb

@@ -0,0 +1,543 @@
+#!/usr/bin/env ruby
+
+module Iodine
+	class Http < ::Iodine::Protocol
+		class Http2 < ::Iodine::Protocol
+			class HPACK
+				class IndexTable
+					attr_reader :size
+					attr_accessor :max_size
+					def initialize
+						@list = []
+						@size = 4_096 # initial defaul size by standard
+						@actual_size = 0
+					end
+					def [] index
+						raise "HPACK Error - invalid header index: 0" if index == 0
+						return STATIC_LIST[index] if index < STATIC_LENGTH
+						raise "HPACK Error - invalid header index: #{index}" if @list.count <= (index - STATIC_LENGTH)
+						@list[index - STATIC_LENGTH]
+					end
+					alias :get_index :[]
+					def get_name index
+						get_index(index)[0]
+					end
+					def insert *field
+						@list.unshift field
+						field.each {|f| @actual_size += f.to_s.bytesize}; @actual_size += 32
+						resize
+						field
+					end
+					def find *field
+						index = STATIC_LIST.index(field)
+						return index if index
+						index = @list.index(field)
+						index ? (index + STATIC_LENGTH) : nil
+					end
+					def find_name name
+						index = 1
+						while STATIC_LIST[index]
+							return index if STATIC_LIST[index][0] == name
+							index += 1
+						end
+						index = 0
+						while @list[index]
+							return index+STATIC_LENGTH if @list[index][0] == name
+							index += 1
+						end
+						nil
+					end
+					def resize value = nil
+						@size = value if value && value <= 4_096
+						while (@actual_size > @size) && @list.any?
+							@list.pop.each {|i| @actual_size -= i.to_s.bytesize}
+							@actual_size -= 32
+						end
+						self
+					end
+				end
+
+				def initialize
+					@decoding_list = IndexTable.new
+					@encoding_list = IndexTable.new
+				end
+
+				def decode data
+					data = StringIO.new data
+					results = {}
+					while (field = decode_field(data))
+						name = (field[0].is_a?(String) && field[0][0] == ':') ? field[0][1..-1].to_sym : field[0]
+						results[name] ? (results[name].is_a?(String) ? (results[name] = [results[name], field[1]]) : (results[name] << field[1]) ) : (results[name] = field[1]) if field[1]
+					end
+					results
+				end
+				def encode headers = {}
+					buffer = ''
+					headers.each {|k, v| buffer << encode_field( (k.is_a?(String) ? k : ":#{k.to_s}".freeze) ,v) if v}
+					buffer
+				end
+				def resize max
+					@decoding_list.resize max
+					@encoding_list.resize max
+				end
+
+				protected
+				def decode_field data # expects a StringIO or other IO object
+					byte = data.getbyte
+					return nil unless byte
+					if byte[7] == 1 # 0b1000_0000 == 0b1000_0000
+						# An indexed header field starts with the '1' 1-bit pattern, followed by the index of the matching header field, represented as an integer with a 7-bit prefix (see Section 5.1).
+						num = extract_number data, byte, 1
+						@decoding_list[num]
+					elsif byte & 192 == 64 # 0b1100_0000 == 0b0100_0000
+						# A literal header field with incremental indexing representation starts with the '01' 2-bit pattern.
+						# If the header field name matches the header field name of an entry stored in the static table or the dynamic table, the header field name can be represented using the index of that entry. In this case, the index of the entry is represented as an integer with a 6-bit prefix (see Section 5.1). This value is always non-zero.
+						# Otherwise, the header field name is represented as a string literal (see Section 5.2). A value 0 is used in place of the 6-bit index, followed by the header field name.
+						num = extract_number data, byte, 2
+						field_name = (num == 0) ? extract_string(data) : @decoding_list.get_name(num)
+						field_value = extract_string(data)
+						@decoding_list.insert field_name, field_value
+					elsif byte & 224 # 0b1110_0000 == 0
+						# A literal header field without indexing representation starts with the '0000' 4-bit pattern.
+						# If the header field name matches the header field name of an entry stored in the static table or the dynamic table, the header field name can be represented using the index of that entry.
+						# In this case, the index of the entry is represented as an integer with a 4-bit prefix (see Section 5.1). This value is always non-zero.
+						# Otherwise, the header field name is represented as a string literal (see Section 5.2) and a value 0 is used in place of the 4-bit index, followed by the header field name.
+						# OR
+						# A literal header field never-indexed representation starts with the '0001' 4-bit pattern + 4+ bits for index
+						num = extract_number data, byte, 4
+						field_name = (num == 0) ? extract_string(data) : @decoding_list.get_name(num)
+						field_value = extract_string(data)
+						[field_name, field_value]
+					elsif byte & 224 == 32 # 0b1110_0000 == 0b0010_0000
+						# A dynamic table size update starts with the '001' 3-bit pattern
+						# followed by the new maximum size, represented as an integer with a 5-bit prefix (see Section 5.1).
+						@decoding_list.resize extract_number(data, byte, 5)
+						[].freeze
+					else
+						raise "HPACK Error - invalid field indicator."
+					end
+				end
+				def encode_field name, value
+					if value.is_a?(Array)
+						return (value.map {|v| encode_field name, v} .join)
+					end
+					if name == 'set-cookie'
+						buffer = ''
+						buffer << pack_number( 55, 16, 4)
+						buffer << pack_string(value)
+						return buffer
+					end
+					index = @encoding_list.find(name, value)
+					return pack_number( index, 1, 1) if index
+					index = @encoding_list.find_name name
+					@encoding_list.insert name, value
+					buffer = ''
+					if index
+						buffer << pack_number( index, 64, 2)
+					else
+						buffer << pack_number( 0, 64, 2)
+						buffer << pack_string(name.to_s)
+					end
+					buffer << pack_string(value)
+					buffer
+				end
+				def extract_number data, prefix, prefix_length
+					mask = 255 >> prefix_length
+					return prefix & mask unless (prefix & mask) == mask
+					count = prefix = 0
+					loop do
+						c = data.getbyte
+						prefix = prefix | ((c & 127) << (7*count))
+						break if c[7] == 0
+						count += 1
+					end
+					prefix + mask
+				# rescue e =>
+				# 	raise "HPACK Error - number input invalid"
+				end
+				def pack_number number, prefix, prefix_length
+					n_length = 8-prefix_length
+					if (number + 1 ).bit_length <= n_length
+						return ((prefix << n_length) | number).chr
+					end
+					prefix = [(prefix << n_length) | (2**n_length - 1)]
+					number -= 2**n_length - 1
+					loop do
+						prefix << ((number & 127) | 128)
+						number = number >> 7
+						break if number == 0
+					end
+					(prefix << (prefix.pop & 127)).pack('C*'.freeze)
+				end
+				def pack_string string, deflate = true
+					string = deflate(string) if deflate
+					(pack_number(string.bytesize, (deflate ? 1 : 0), 1) + string).force_encoding ::Encoding::ASCII_8BIT
+				end
+				def extract_string data
+					byte = data.getbyte
+					hoffman = byte[7] == 1
+					length = extract_number data, byte, 1
+					if hoffman
+						inflate data.read(length)
+					else
+						data.read length
+					end
+				end
+				def inflate data
+					data = StringIO.new data
+					str = ''
+					buffer = ''
+					until data.eof?
+						byte = data.getbyte
+						8.times do |i|
+							buffer << byte[7-i].to_s
+							if HUFFMAN[buffer]
+								str << HUFFMAN[buffer].chr rescue raise("HPACK Error - Huffman EOS found")
+								buffer.clear
+							end
+						end
+					end
+					raise "HPACK Error - Huffman padding too long (#{buffer.length}): #{buffer}" if buffer.length > 29
+					str
+				end
+				def deflate data
+					str = ''
+					buffer = ''
+					data.bytes.each do |i|
+						buffer << HUFFMAN.key(i)
+						if (buffer % 8) == 0
+							str << [buffer].pack('b*')
+							buffer.clear
+						end
+					end
+					(8-(buffer.bytesize % 8)).times { buffer << '1'}
+					str << [buffer].pack('b*')
+					buffer.clear
+					str
+				end
+				STATIC_LIST = [ nil,
+					[":authority"],
+					[":method", "GET" ],
+					[":method", "POST" ],
+					[":path", "/" ],
+					[":path", "/index.html" ],
+					[":scheme", "http" ],
+					[":scheme", "https" ],
+					[":status", "200" ],
+					[":status", "204" ],
+					[":status", "206" ],
+					[":status", "304" ],
+					[":status", "400" ],
+					[":status", "404" ],
+					[":status", "500" ],
+					["accept-charset"],
+					["accept-encoding", "gzip, deflate" ],
+					["accept-language"],
+					["accept-ranges"],
+					["accept"],
+					["access-control-allow-origin"],
+					["age"],
+					["allow"],
+					["authorization"],
+					["cache-control"],
+					["content-disposition"],
+					["content-encoding"],
+					["content-language"],
+					["content-length"],
+					["content-location"],
+					["content-range"],
+					["content-type"],
+					["cookie"],
+					["date"],
+					["etag"],
+					["expect"],
+					["expires"],
+					["from"],
+					["host"],
+					["if-match"],
+					["if-modified-since"],
+					["if-none-match"],
+					["if-range"],
+					["if-unmodified-since"],
+					["last-modified"],
+					["link"],
+					["location"],
+					["max-forwards"],
+					["proxy-authenticate"],
+					["proxy-authorization"],
+					["range"],
+					["referer"],
+					["refresh"],
+					["retry-after"],
+					["server"],
+					["set-cookie"],
+					["strict-transport-security"],
+					["transfer-encoding"],
+					["user-agent"],
+					["vary"],
+					["via"],
+					["www-authenticate"] ].map! {|a| a.map! {|s| s.is_a?(String) ? s.freeze : s } && a.freeze if a}
+				STATIC_LENGTH = STATIC_LIST.length
+
+				HUFFMAN = [
+					"1111111111000", 
+					"11111111111111111011000", 
+					"1111111111111111111111100010", 
+					"1111111111111111111111100011", 
+					"1111111111111111111111100100", 
+					"1111111111111111111111100101", 
+					"1111111111111111111111100110", 
+					"1111111111111111111111100111", 
+					"1111111111111111111111101000", 
+					"111111111111111111101010", 
+					"111111111111111111111111111100", 
+					"1111111111111111111111101001", 
+					"1111111111111111111111101010", 
+					"111111111111111111111111111101", 
+					"1111111111111111111111101011", 
+					"1111111111111111111111101100", 
+					"1111111111111111111111101101", 
+					"1111111111111111111111101110", 
+					"1111111111111111111111101111", 
+					"1111111111111111111111110000", 
+					"1111111111111111111111110001", 
+					"1111111111111111111111110010", 
+					"111111111111111111111111111110", 
+					"1111111111111111111111110011", 
+					"1111111111111111111111110100", 
+					"1111111111111111111111110101", 
+					"1111111111111111111111110110", 
+					"1111111111111111111111110111", 
+					"1111111111111111111111111000", 
+					"1111111111111111111111111001", 
+					"1111111111111111111111111010", 
+					"1111111111111111111111111011", 
+					"010100", 
+					"1111111000", 
+					"1111111001", 
+					"111111111010", 
+					"1111111111001", 
+					"010101", 
+					"11111000", 
+					"11111111010", 
+					"1111111010", 
+					"1111111011", 
+					"11111001", 
+					"11111111011", 
+					"11111010", 
+					"010110", 
+					"010111", 
+					"011000", 
+					"00000", 
+					"00001", 
+					"00010", 
+					"011001", 
+					"011010", 
+					"011011", 
+					"011100", 
+					"011101", 
+					"011110", 
+					"011111", 
+					"1011100", 
+					"11111011", 
+					"111111111111100", 
+					"100000", 
+					"111111111011", 
+					"1111111100", 
+					"1111111111010", 
+					"100001", 
+					"1011101", 
+					"1011110", 
+					"1011111", 
+					"1100000", 
+					"1100001", 
+					"1100010", 
+					"1100011", 
+					"1100100", 
+					"1100101", 
+					"1100110", 
+					"1100111", 
+					"1101000", 
+					"1101001", 
+					"1101010", 
+					"1101011", 
+					"1101100", 
+					"1101101", 
+					"1101110", 
+					"1101111", 
+					"1110000", 
+					"1110001", 
+					"1110010", 
+					"11111100", 
+					"1110011", 
+					"11111101", 
+					"1111111111011", 
+					"1111111111111110000", 
+					"1111111111100", 
+					"11111111111100", 
+					"100010", 
+					"111111111111101", 
+					"00011", 
+					"100011", 
+					"00100", 
+					"100100", 
+					"00101", 
+					"100101", 
+					"100110", 
+					"100111", 
+					"00110", 
+					"1110100", 
+					"1110101", 
+					"101000", 
+					"101001", 
+					"101010", 
+					"00111", 
+					"101011", 
+					"1110110", 
+					"101100", 
+					"01000", 
+					"01001", 
+					"101101", 
+					"1110111", 
+					"1111000", 
+					"1111001", 
+					"1111010", 
+					"1111011", 
+					"111111111111110", 
+					"'", 
+					"11111111111101", 
+					"1111111111101", 
+					"1111111111111111111111111100", 
+					"11111111111111100110", 
+					"1111111111111111010010", 
+					"11111111111111100111", 
+					"11111111111111101000", 
+					"1111111111111111010011", 
+					"1111111111111111010100", 
+					"1111111111111111010101", 
+					"11111111111111111011001", 
+					"1111111111111111010110", 
+					"11111111111111111011010", 
+					"11111111111111111011011", 
+					"11111111111111111011100", 
+					"11111111111111111011101", 
+					"11111111111111111011110", 
+					"111111111111111111101011", 
+					"11111111111111111011111", 
+					"111111111111111111101100", 
+					"111111111111111111101101", 
+					"1111111111111111010111", 
+					"11111111111111111100000", 
+					"111111111111111111101110", 
+					"11111111111111111100001", 
+					"11111111111111111100010", 
+					"11111111111111111100011", 
+					"11111111111111111100100", 
+					"111111111111111011100", 
+					"1111111111111111011000", 
+					"11111111111111111100101", 
+					"1111111111111111011001", 
+					"11111111111111111100110", 
+					"11111111111111111100111", 
+					"111111111111111111101111", 
+					"1111111111111111011010", 
+					"111111111111111011101", 
+					"11111111111111101001", 
+					"1111111111111111011011", 
+					"1111111111111111011100", 
+					"11111111111111111101000", 
+					"11111111111111111101001", 
+					"111111111111111011110", 
+					"11111111111111111101010", 
+					"1111111111111111011101", 
+					"1111111111111111011110", 
+					"111111111111111111110000", 
+					"111111111111111011111", 
+					"1111111111111111011111", 
+					"11111111111111111101011", 
+					"11111111111111111101100", 
+					"111111111111111100000", 
+					"111111111111111100001", 
+					"1111111111111111100000", 
+					"111111111111111100010", 
+					"11111111111111111101101", 
+					"1111111111111111100001", 
+					"11111111111111111101110", 
+					"11111111111111111101111", 
+					"11111111111111101010", 
+					"1111111111111111100010", 
+					"1111111111111111100011", 
+					"1111111111111111100100", 
+					"11111111111111111110000", 
+					"1111111111111111100101", 
+					"1111111111111111100110", 
+					"11111111111111111110001", 
+					"11111111111111111111100000", 
+					"11111111111111111111100001", 
+					"11111111111111101011", 
+					"1111111111111110001", 
+					"1111111111111111100111", 
+					"11111111111111111110010", 
+					"1111111111111111101000", 
+					"1111111111111111111101100", 
+					"11111111111111111111100010", 
+					"11111111111111111111100011", 
+					"11111111111111111111100100", 
+					"111111111111111111111011110", 
+					"111111111111111111111011111", 
+					"11111111111111111111100101", 
+					"111111111111111111110001", 
+					"1111111111111111111101101", 
+					"1111111111111110010", 
+					"111111111111111100011", 
+					"11111111111111111111100110", 
+					"111111111111111111111100000", 
+					"111111111111111111111100001", 
+					"11111111111111111111100111", 
+					"111111111111111111111100010", 
+					"111111111111111111110010", 
+					"111111111111111100100", 
+					"111111111111111100101", 
+					"11111111111111111111101000", 
+					"11111111111111111111101001", 
+					"1111111111111111111111111101", 
+					"111111111111111111111100011", 
+					"111111111111111111111100100", 
+					"111111111111111111111100101", 
+					"11111111111111101100", 
+					"111111111111111111110011", 
+					"11111111111111101101", 
+					"111111111111111100110", 
+					"1111111111111111101001", 
+					"111111111111111100111", 
+					"111111111111111101000", 
+					"11111111111111111110011", 
+					"1111111111111111101010", 
+					"1111111111111111101011", 
+					"1111111111111111111101110", 
+					"1111111111111111111101111", 
+					"111111111111111111110100", 
+					"111111111111111111110101", 
+					"11111111111111111111101010", 
+					"11111111111111111110100", 
+					"11111111111111111111101011", 
+					"111111111111111111111100110", 
+					"11111111111111111111101100", 
+					"11111111111111111111101101", 
+					"111111111111111111111100111", 
+					"111111111111111111111101000", 
+					"111111111111111111111101001", 
+					"111111111111111111111101010", 
+					"111111111111111111111101011", 
+					"1111111111111111111111111110", 
+					"111111111111111111111101100", 
+					"111111111111111111111101101", 
+					"111111111111111111111101110", 
+					"111111111111111111111101111", 
+					"111111111111111111111110000", 
+					"11111111111111111111101110", 
+					"111111111111111111111111111111"].each_with_index.with_object({}) {|a, h| h[a[0]] = a[1] }
+			end
+		end
+	end
+end