udp_rest 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c547a1a4aeafe5240118f42f1d060b861bba377
+  data.tar.gz: 1f67cc942b89d5d8da7b12066d019b96eaa54cf1
+SHA512:
+  metadata.gz: 637dbc37f4e52a049b500f09aa60dcf167f27434fcfc9c2ea5c5fe8b442fc128e1d8cccf6b35c14ea42f3596c135cd1df3b03a1a5dea8f34f663dc8d56ebac33
+  data.tar.gz: e592fdfff3610df362d4a558d15bda20dde2b61302f4bafdb1ddbaebca62053291e71f101e349308ea8eb849725ae21e3cb6050ba5bcaaaa44fdb0b5d780ac0e

data/.gitignore

@@ -0,0 +1 @@
+pkg/

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    udp_rest (0.9.0)
+      colorize
+      trollop
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colorize (0.8.1)
+    rake (10.5.0)
+    trollop (2.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  rake (~> 10.0)
+  udp_rest!
+
+BUNDLED WITH
+   1.12.5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nathan Reed
+
+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/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "udp_rest"
+
+# 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

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/demo/simple_server.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'time'
+require 'udp_rest'
+
+req_count = 0
+port = (ARGV.last || 7890).to_i
+puts "listening on 0.0.0.0:#{port}..."
+
+UDPRest::Server.new(:port => port) do |s|
+	s.get '/' do
+		"Hello, World!\nVisit http://github.com/reednj/udp_rest for more info"
+	end
+
+	s.get '/hello' do
+		'hello'
+	end
+
+	s.post '/time' do
+		Time.now.to_s
+	end
+
+	s.get '/time/unix' do
+		Time.now.to_i
+	end
+
+	s.get '/time/iso' do
+		Time.now.iso8601
+	end
+
+	s.get '/count' do
+		req_count += 1
+		req_count.to_s
+	end
+
+	s.get '/too_long' do
+		'a' * 600
+	end
+
+end

data/exe/udp-rest

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'rest_client'
+App.new.main

data/lib/rest_client.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'colorize'
+require 'trollop'
+require 'udp_rest'
+
+class App
+	def main
+		valid_methods = ['GET', 'PUT', 'POST', 'DELETE']
+		@opts = Trollop::options do
+			version "UDP RestClient (c) 2016 @reednj"
+			banner "Usage: udp-rest [options] <url>"
+			opt :method, "HTTP Method (GET, POST etc)", :type => :string, :default => 'GET'
+			opt :headers, "Show the response headers", :default => false
+		end
+
+		Trollop::educate if ARGV.empty?
+		url = ARGV.last
+		url = "uhttp://" + url unless url.start_with? 'uhttp://'
+
+		begin
+			if !valid_methods.include? @opts[:method].upcase
+				raise "Invalid REST method '#{@opts[:method]}'"
+			end
+
+			r = UDPRest::Client.uhttp(@opts[:method], url)
+			print_response(r)
+		rescue => e
+			puts e
+		end
+	end
+
+	def print_response(r)
+		if @opts[:headers]
+			puts r.ok? ? r.status_line.green : r.status_line.red
+			puts ''
+		end
+
+		puts r.text
+	end
+end

data/lib/udp_rest.rb

@@ -0,0 +1,139 @@
+require 'uri'
+require 'socket'
+
+require 'worker_thread'
+require "udp_rest/version"
+require "udp_rest/udp"
+require "udp_rest/uhttp"
+
+module UDPRest
+	class Server
+		def initialize(options = {})
+			@udp = UDPServer.new
+			@routes = {}
+
+			if block_given?
+				yield(self) 
+				port = options[:port] || 80
+				options[:host] = options[:host] || '0.0.0.0'
+				self.listen(port, options)
+			end
+		end
+
+		def udp_server
+			@udp
+		end
+
+		def post(path, &block)
+			add_route('POST', path, &block)
+		end
+
+		def get(path, &block)
+			add_route('GET', path, &block)
+		end
+
+		def add_route(req_method, path, &block)
+			key = "#{req_method.upcase} #{path}"
+			@routes[key] = Proc.new &block 		
+			return key
+		end
+
+		def route_request(request)
+			key = "#{request.req_method.upcase} #{request.path}"
+			puts key
+
+			block = @routes[key]
+			return respond(404, 'Not Found') if block.nil?
+			
+			# handle the response. No matter what gets returned
+			# we want to try and make it into something useful
+			result = block.call(request, self)
+			return result if result.is_a? UHTTPResponse
+			return respond(200, result.to_s) if result.respond_to? :to_s
+			return respond(200, 'ok')
+		end
+
+		def listen(port, options = {})
+			port = port || 80
+
+			@udp.listen(port, options) do |packet|
+				response = nil
+
+				if response.nil?
+					begin
+						request = UHTTPRequest.from_packet packet
+					rescue => e
+						puts "400 BAD REQUEST: #{e}"
+						response = respond(400, 'Bad Request')
+					end
+				end
+
+				if response.nil?
+					begin
+						response = route_request(request)
+
+						if response.to_s.bytesize > udp_server.max_packet_size
+							raise "response too long (#{response.to_s.bytesize} bytes)"
+						end
+					rescue => e
+						puts "500 APPLICATION ERROR: #{e}"
+						response = respond(500, 'Application Error')
+					end
+				end
+
+				@udp.send(response.to_s, packet.src_addr, packet.src_port)
+			end
+		end
+
+		def respond(code, text)
+			UHTTPResponse.new(code, :text => text)
+		end
+	end
+
+	class Client
+		attr_accessor :host
+		attr_accessor :port
+		attr_accessor :socket
+		attr_accessor :timeout
+
+		def initialize(host, port)
+			@max_packet_size = 512
+
+			self.host = host
+			self.port = port
+			self.socket = UDPSocket.new
+			self.timeout = 5.0
+		end
+
+		def send_text(text)
+			thread = WorkerThread.new.start :timeout => self.timeout do
+				self.socket.send(text, 0, self.host, self.port)
+				response_data = self.socket.recvfrom(@max_packet_size)
+				UDPPacket.new(response_data)
+			end
+
+			thread.join
+			packet = thread.value
+			raise "Request Timeout (#{host}:#{port})" if packet.nil?
+			return packet
+		end
+
+		def self.uhttp(req_method, url)
+			uri = URI(url)
+			client = self.new(uri.host, uri.port || 80)
+			
+			req = UHTTPRequest.new
+			req.req_method = req_method
+			req.path = uri.path
+
+			packet = client.send_text(req.to_s)
+			UHTTPResponse.parse(packet.text)
+		end
+
+		def self.get(url)
+			self.uhttp('GET', url)
+		end
+		
+	end
+
+end

data/lib/udp_rest/udp.rb

@@ -0,0 +1,71 @@
+require 'uri'
+require 'socket'
+
+module UDPRest
+
+    class UDPRest::UDPServer
+        attr_accessor :socket
+
+        def initialize
+            @max_packet_size = 512
+            self.socket = UDPSocket.new
+        end
+
+        def max_packet_size
+            @max_packet_size
+        end
+
+        def listen(port, options = {})
+            @port = port.to_i
+            @host = options[:host] || '0.0.0.0'
+            self.socket.bind(@host, @port)
+
+            loop do
+                response = self.receive()
+                yield(response)
+            end
+        end
+
+        def receive
+            data = self.socket.recvfrom(@max_packet_size)
+            UDPPacket.new(data)
+        end
+
+        def send(text, host, port)
+            raise "message too long (max is #{@max_packet_size}b, was #{text.bytesize})" if text.bytesize > @max_packet_size
+            self.socket.send(text, 0, host, port)
+        end
+
+        def host
+            @host
+        end
+
+        def port
+            @port
+        end
+
+    end
+
+    class UDPRest::UDPPacket
+        attr_accessor :text
+        attr_accessor :addr_family
+        attr_accessor :src_port
+        attr_accessor :src_addr
+
+        def initialize(data = nil)
+            # assume this was initialized with the standard data structure
+            # that is returned by UDPSocket
+            if !data.nil?
+                self.text = data[0]
+                self.addr_family = data[1][0]
+                self.src_port = data[1][1]
+                self.src_addr = data[1][2]
+            end
+        end
+
+        def to_s
+            self.text
+        end
+    end
+
+end

data/lib/udp_rest/uhttp.rb

@@ -0,0 +1,72 @@
+require 'uri'
+require 'socket'
+
+module UDPRest
+
+    class UDPRest::UHTTPRequest
+        attr_accessor :req_method
+        attr_accessor :path
+        attr_accessor :protocol
+
+        def initialize
+            self.req_method = 'GET'
+            self.protocol = 'UHTTP/1.0'
+            self.path ='/'
+        end
+
+        def self.from_packet(p)
+            text = p
+            text = p.text if text.is_a? UDPPacket
+            data = text.split(' ')
+
+            raise 'invalid request' if data.length != 3
+            req = self.new
+            req.req_method = data[0]
+            req.path = data[1]
+            req.protocol = data[2]
+            return req
+        end
+
+        def to_s
+            self.path = '/' if path.nil? || path.empty?
+            "#{req_method} #{path} #{protocol}\n"
+        end
+    end
+
+    class UDPRest::UHTTPResponse
+        attr_accessor :code
+        attr_accessor :protocol
+        attr_accessor :text
+
+        def initialize(code, options = {})
+            self.code = code.to_i
+            self.protocol = options[:protocol] || 'UHTTP/1.0'
+            self.text = options[:text] || ''
+        end
+
+        def self.parse(s)
+            data = s.split("\n\n")
+            status = data[0].split(' ')
+            text = data[1] if data.length > 1
+            self.new(status[1], :text => text || '')
+        end
+
+        def ok?
+            code == 200
+        end
+
+        def status_text
+            return 'OK' if ok?
+            return 'FAILED'
+        end
+
+        def status_line
+            "#{protocol} #{code} #{status_text}"
+        end
+
+        def to_s
+            "#{status_line}\n\n#{text}"
+        end
+    end
+
+end

data/lib/udp_rest/version.rb

@@ -0,0 +1,3 @@
+module UDPRest
+  VERSION = "0.9.0"
+end

data/lib/worker_thread.rb

@@ -0,0 +1,42 @@
+# Helper for running threads in the background, with a timeout
+# and error logging.
+#
+# Example:
+#
+#    WorkerThread.new.start :timeout => 5.minutes do 
+#        # long running task here...
+#        sleep 10.0
+#    end
+#
+class WorkerThread
+
+	def start(options = nil)
+		raise 'background_task needs a block' unless block_given?
+
+		options ||= {}
+
+		worker = Thread.new do
+			begin
+				yield
+			rescue => e
+				$stderr.puts "#{Time.now}\t#{e.class.to_s}\t#{e.message}\n"
+				raise e
+			end
+		end
+
+		# if the user set a timeout then we need a thread to monitor
+		# the worker to make sure it doesn't run too long
+		if !options[:timeout].nil?
+			Thread.new do
+				sleep options[:timeout].to_f
+				
+				if worker.status != false
+					#$stderr.puts "#{Time.now}\tbackground_task thread timeout\n"
+					worker.kill
+				end
+			end
+		end
+
+		worker
+	end
+end

data/readme.md

@@ -0,0 +1,35 @@
+# REST over UDP
+
+ - Most REST requets are very small
+ - it should be possible to implement a simple version of HTTP that can run over UDP in order to make REST requets
+ - we have implemented that
+  - the max packet size is 512 bytes
+ - This gem makes it easy to create servers and clients for udp-rest
+ - it also contains a curl-like command line app
+ - obviously this is not going to work from any browser, but it can be useful for simple command line apps.
+
+## Try it out
+
+There is a udp rest server running on uhttp.reednj.com. You can make requests to it by installing the gem.
+
+		gem install udp_rest
+		udp-rest uhttp.reednj.com
+
+		<SCREEN SHOT OF CONSOLE>
+
+## Server
+
+Use this gem to create sinatra style servers to respond to requests.
+
+		<CODE>
+
+## Client
+
+## Benchmarks
+
+ - do some testing of the latency here, see if it really is faster. Pick a few different servers
+
+## Other Points
+
+ - encoding is always UTF-8
+ - the max request and response size is 512 bytes

data/udp_rest.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'udp_rest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "udp_rest"
+  spec.version       = UDPRest::VERSION
+  spec.authors       = ["Nathan Reed"]
+  spec.email         = ["reednj@gmail.com"]
+
+  spec.summary       = %q{Client and server modules to allow making REST HTTP requests over UDP}
+  spec.homepage      = "https://github.com/reednj/udp_rest"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.required_ruby_version = '>=1.9.3'
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency  'colorize'
+  spec.add_dependency  'trollop'
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: udp_rest
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Nathan Reed
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- reednj@gmail.com
+executables:
+- udp-rest
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- Rakefile
+- bin/console
+- bin/setup
+- demo/simple_server.rb
+- exe/udp-rest
+- lib/rest_client.rb
+- lib/udp_rest.rb
+- lib/udp_rest/udp.rb
+- lib/udp_rest/uhttp.rb
+- lib/udp_rest/version.rb
+- lib/worker_thread.rb
+- readme.md
+- udp_rest.gemspec
+homepage: https://github.com/reednj/udp_rest
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Client and server modules to allow making REST HTTP requests over UDP
+test_files: []