thrurl 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a8ea299751ef830fd45369afb732a79b6d2ccd3
+  data.tar.gz: e63a443330de3020e67962597cf891c8cc8cbd3f
+SHA512:
+  metadata.gz: d24d0f51a83bd2a430bc32a82873282640b39490844aaa6ac2d44182f2638ae9015ad1010243703617019cbf9127262d4ba6bfceecaa8f1cac509a44e21aff5d
+  data.tar.gz: 295ee639580cda621f0d9fb697f1b30c1cd5baf8fb267d2089b661a4773101cf8184b02f5178d2e797e5f06aa8811632edbafa231a29c650708e25ca52a9f781

data/README.md

@@ -0,0 +1,23 @@
+# Thrurl - Thrift meets cURL
+
+A small utility for accessing [Thrift](http://en.wikipedia.org/wiki/Apache_Thrift) services from the command line, without having to write a service-specific client. Useful for debugging purposes, trying out services, writing integration tests, etc.
+
+## Dependencies
+
+You need to have [`thrift`](http://thrift.apache.org/) installed. You also need to have the IDL files (`.thrift`) related to the service you want to call. Thrurl will compile them into Ruby code and parse your parameters to match the expected types automatically.
+
+## How to use
+
+Thrurl is a command line client, much like cURL. Using it is simple:
+
+```
+thrurl -h "my-thrift-server" -p 5000 -m "checkinsPerLocation" -s "CheckinService" -a "{ user: { id: 1 } }"
+
+```
+
+Thrurl will parse the response and display it in JSON format (in case you want to use the output of the script, and because it's a nice human readable format).
+
+## Things to improve
+
+- The error messages when e.g. fields are missing or have the wrong type is still *very* cryptic
+- If you use enums, you have to pass in the *value* of the enum

data/bin/thrurl

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'args_reader'
+require 'client'
+require 'thrift_generator'
+require 'pp'
+
+configs = ArgsReader.new(ARGV).configs
+
+thrift_module = ThriftGenerator.new(configs[:service]).generate_if_needed
+
+resp = Client.new(thrift_module::Client, configs).call
+
+puts ObjectInspector.new(resp).response_map.to_json

data/lib/args_reader.rb

@@ -0,0 +1,44 @@
+class ArgsReader
+	attr_accessor :configs
+
+	def initialize(args)
+		arg_map = Hash[*args]
+		validate_configs!(arg_map)
+
+		self.configs = {
+			host: arg_map["-h"],
+			port: arg_map["-p"],
+			method: arg_map["-m"],
+			service: arg_map["-s"],
+			params: eval(arg_map["-a"])
+		}
+	end
+
+	def args_and_help
+	  {
+			"-h" => "Service host",
+			"-p" => "Service port",
+			"-s" => "The name of the service (as defined on the IDL)",
+			"-m" => "The method getting called (as defined on the IDL)",
+			"-a" => "The arguments for the call as a Ruby Hash"
+		}
+	end
+
+	def usage_string
+		args_and_help.map { |k, v|
+			"  #{k.ljust(4)} #{v}"
+		}
+	end
+
+	def validate_configs!(arg_map)
+		missing = args_and_help.keys.select { |k| arg_map[k].nil? }
+		if !missing.empty?
+			puts "Missing required parameters: #{missing.join(', ')}\n\n"
+			puts "Required parameters:"
+			puts usage_string
+			puts "\nExample usage:\n"
+			puts "thrurl -h \"localhost\" -p 5000 -m \"checkinsPerLocation\" -s \"CheckinService\" -a \"{ user: { id: 1 } }\"\n\n"
+			exit 1
+		end
+	end
+end

data/lib/client.rb

@@ -0,0 +1,22 @@
+require 'thrift'
+require 'json'
+require_relative 'method_call'
+require_relative 'type_adapter'
+
+class Client
+	def initialize(client_thrift_class, config)
+		@transport = ::Thrift::FramedTransport.new(::Thrift::Socket.new(config[:host], config[:port]))
+		protocol = ::Thrift::BinaryProtocol.new(@transport)
+ 
+		@client = client_thrift_class.new(protocol)
+		@call = MethodCall.new(config[:service], config[:method], config[:params])
+	end
+ 
+	def call
+		@transport.open
+		resp = @client.send(*@call.args)
+		@transport.close
+		resp
+	end
+
+end

data/lib/method_call.rb

@@ -0,0 +1,60 @@
+require_relative 'object_inspector'
+require 'pp'
+
+class MethodCall
+	attr_accessor :args
+ 
+	def initialize(service_name, method, values)
+		eval(service_name)
+
+		args_type = eval("#{service_name}::#{upcase_first(method)}_args") rescue nil
+
+		evaluate_method(args_type, service_name, method)
+		@inspector = ObjectInspector.new(args_type.new)
+
+		args = evaluate_args(args_type, values)
+
+		self.args = [method] + args
+	end
+
+	def evaluate_method(args_type, service_name, method)
+		if args_type.nil?
+			puts "\nMethod not found: #{method}\n\nThe following methods are available:"
+			puts inspect_methods(service_name)
+			exit 1
+		end
+	end		
+
+	def evaluate_args(args_type, values)
+		args = TypeAdapter.new(
+			{ type: ::Thrift::Types::STRUCT, class: args_type }, 
+			values
+		).field_values rescue nil
+
+		if args.nil?
+			puts "Error processing args: #{values.to_json}\nExpected args:\n"
+			pp inspect_args
+			puts "\nExample argument with all optional fields:\n\n"
+			puts sample_call
+			exit 1
+		end
+
+		args
+	end
+
+	def inspect_args
+		@inspector.args_tree
+	end
+
+	def sample_call
+		@inspector.sample_call
+	end
+
+	def inspect_methods(base_class)
+		ObjectInspector.new(eval(base_class)).available_methods.join("\n")
+	end
+ 
+	def upcase_first(str)
+		str[0].upcase + str[1..-1]
+	end
+end

data/lib/object_inspector.rb

@@ -0,0 +1,101 @@
+# this is rather hacky, but...
+require 'thrift/types'
+
+class ObjectInspector
+  def initialize(obj)
+    @obj = obj
+  end
+
+  def sample_call
+    type_tree_for(@obj.class, {}, sample_values)
+  end
+
+  def args_tree
+    type_tree_for(@obj.class, {}, type_names)
+  end
+
+  def response_map
+    response_tree(@obj, {})
+  end
+
+  def available_methods
+    @obj.constants.map { |c| 
+      c.to_s.split("_args").first if c.to_s.end_with?("_args")
+    }.compact
+  end
+
+  private
+
+  def response_tree(obj, tree)
+    obj.struct_fields.values.each { |i|
+      tree[i[:name]] = response_fields(obj.send(i[:name]))
+    }
+    tree
+  end
+
+  def response_fields(obj)
+    if obj.is_a?(Array)
+      obj.map { |f| response_fields(f) }
+    elsif obj.is_a?(Hash)
+      Hash[*
+        obj.each { |k, v|
+          [k, response_fields(v)]
+        }
+      ]
+    elsif obj.is_a?(::Thrift::Struct)
+      response_tree(obj, {})
+    else
+      obj
+    end
+  end
+
+  def type_tree_for(obj, tree, value_mapping)
+    obj::FIELDS.values.map { |f| type_annotation_for(f, tree, value_mapping) }
+    tree
+  end
+
+  def type_annotation_for(field, tree, value_mapping)
+    if(field[:class])
+      tree[field_name(field)] = type_tree_for(field[:class], {}, value_mapping)
+    elsif field[:type] == ::Thrift::Types::MAP
+      tree[field_name(field)] = { 
+        type_annotation_for(field[:key], {}, value_mapping).values.first => 
+          type_annotation_for(field[:value], {}, value_mapping).values.first
+      }
+    elsif field[:type] == ::Thrift::Types::SET || field[:type] == ::Thrift::Types::LIST
+      tree[field_name(field)] = type_annotation_for(field[:element], {}, value_mapping).values
+    else
+      tree[field_name(field)] = value_mapping[field[:type]]
+    end
+    tree
+  end
+
+  def field_name(field)
+    field[:name]
+  end
+
+  def type_names
+    {
+      ::Thrift::Types::BOOL => "boolean",
+      ::Thrift::Types::BYTE => "integer",
+      ::Thrift::Types::I16 => "integer",
+      ::Thrift::Types::I32 => "integer",
+      ::Thrift::Types::I64 => "integer",
+      ::Thrift::Types::DOUBLE => "double",
+      ::Thrift::Types::STRING => "string"
+    }
+  end
+
+  def sample_values
+    {
+      ::Thrift::Types::BOOL => true,
+      ::Thrift::Types::BYTE => 1,
+      ::Thrift::Types::I16 => 12,
+      ::Thrift::Types::I32 => 123,
+      ::Thrift::Types::I64 => 1234,
+      ::Thrift::Types::DOUBLE => 12.34,
+      ::Thrift::Types::STRING => "foo"
+    }
+  end
+
+end

data/lib/thrift_generator.rb

@@ -0,0 +1,34 @@
+class ThriftGenerator
+
+	GEN_FOLDER = "gen-rb"
+
+	def initialize(module_name)
+		@base_dir = File.expand_path Dir.getwd
+		@module_name = module_name
+		@idl = "#{module_name.downcase}.thrift"
+	end
+
+	def generate_if_needed(&block)
+		# puts "Generating Ruby classes for all available thrift files in #{@base_dir}/#{GEN_FOLDER}"
+		Dir.glob("*.thrift").each { |f|
+			# puts "Compiling #{f}"
+			`thrift -r --gen rb #{f}`
+		}
+
+		service_file = @base_dir + "/#{GEN_FOLDER}/#{@module_name.downcase}.rb"
+		
+		if !File.exists?(service_file)
+			puts "Could not generate code for module #{@module_name} - can't find .thrift file"
+			exit 1
+		end
+
+		load_module(service_file)
+	end
+
+	def load_module(service_file)
+		$LOAD_PATH.unshift(GEN_FOLDER)
+		require service_file
+		eval(@module_name)
+  end		
+
+end

data/lib/type_adapter.rb

@@ -0,0 +1,48 @@
+class TypeAdapter
+ 	attr_accessor :adapted
+
+	def initialize(metadata, values)
+		case metadata[:type]
+		when ::Thrift::Types::STRUCT
+			fields = adapt(metadata[:class]::FIELDS.values, values)
+			self.adapted = metadata[:class].new(fields)
+
+		when ::Thrift::Types::LIST
+			self.adapted = values.map { |v| 
+				adapt_field(metadata[:element], v) 
+			}
+
+		when ::Thrift::Types::MAP
+			self.adapted = Hash[*values.map { |v| 
+				[
+					adapt_field(metadata[:key], v),
+					adapt_field(metadata[:value], v)
+				]
+			}]
+
+		else
+			self.adapted = values
+		end
+	end
+
+	def field_values
+		self.adapted.struct_fields.values.collect { |f| self.adapted.send(f[:name]) }
+	end
+
+
+	private
+
+	def adapt(metadata, values)
+		adapted_params = {}
+		values.each_with_index { |v, i|
+			meta = metadata.find { |m| m[:name] == v.first.to_s }
+			adapted_params[v.first] = adapt_field(meta, v.last)
+		}
+		adapted_params
+	end
+
+	def adapt_field(metadata, value)
+		TypeAdapter.new(metadata, value).adapted
+	end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: thrurl
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Herval Freire
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thrift
+  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: Call Thrift services from the command line, as easily as a cURL
+email: hervalfreire@gmail.com
+executables:
+- thrurl
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/thrurl
+- lib/args_reader.rb
+- lib/client.rb
+- lib/method_call.rb
+- lib/object_inspector.rb
+- lib/thrift_generator.rb
+- lib/type_adapter.rb
+homepage: https://github.com/herval/thrurl
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Call Thrift services from the command line, as easily as a cURL
+test_files: []