jstp 0.5.7 → 1.0.2

data/README.md

@@ -49,9 +49,32 @@ Gateways
 
 Every JSTP server knows its own hostname, which should match the first string in the resource array of the message. If the host as received in the message does not corresponds to this server, it should look up for the right server and dispatch it.
 
-## Installation
+API
+---
+
+The API of the JSTP Ruby Gem remained undocumented, mainly because right now it is sketchy. Here I write some guidelines:
+
+-   It should be possible to pass a Logger as argument to JSTP so that ingoing and outgoing dispatches and exceptions are logged.
+-   Now that JSTP is an engine, lets drop the DSL in the main object and use the standard Ruby configuration strategy:
+
+        JSTP.config do |config|
+            config.strategy outgoing: :tcp, ingoing: :websocket
+            config.port outgoing: 80, ingoing: 65
+            config.hostname "session.manager"
+            config.logger Logger.new
+        end 
+
+-   A block as a middleware should also be configurable in the dispatch, similar to the former implementation.
+-   The engine should be configured with a hostname that will override the linux hostname found automatically by JSTP. This hostname will be used to detect dispatches as aimed to this node.
+-   The engine should automatically forward ingoing dispatches that carry a different hostname from the one of this node to the corresponding node. In this way, each JSTP Node is automatically a gateway.
+-   There should be a DSL in the Controller class for creating aahnd sending a JSTP Dispatch. The library should be able to recognize when an outgoing dispatch is actually aimed at self, so it gets mapped correctly without the need to generate network activity. This DSL should provide also an easy way to switch outgoing strategies.
+-   The message as passed to the Controller's initializer should be made into a Private Class Data. In this context, I should explore a little the idea of mapping the ingoing Dispatch into a class.
+-   Test implementation with Oj JSON parser/dumper.
+-   The Dispatch class should have a Writer an Reader that make it possible to log and parse dispatches from the abbreviated, similar-to-HTTP syntax.
+-   [distant future] Support for SSL/TLS.
 
-Add this line to your application's Gemfile:
+## Installation
+Add this line to your application's Gemfile: 
 
     gem 'jstp'
 
@@ -61,4 +84,4 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install jstp
+    $ gem install jstp

data/jstp.gemspec

@@ -13,8 +13,9 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'discoverer'
   gem.add_dependency 'symbolmatrix'
   gem.add_dependency 'uuid'
+  gem.add_dependency 'oj'
 
-  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec', '>= 2.1.0'
   gem.add_development_dependency 'cucumber'
 
   gem.files         = `git ls-files`.split($\)

data/lib/jstp.rb

@@ -6,20 +6,32 @@ require 'json'
 require 'discoverer'
 require 'symbolmatrix'
 require 'uuid'
-
-require 'jstp/web_socket'
-require 'jstp/tcp'
-
-require 'jstp/api'
-require 'jstp/base'
-require 'jstp/connector'
+require 'oj'
+require 'logger'
 
 require 'jstp/engine'
 require 'jstp/controller'
+require 'jstp/dispatch'
+require 'jstp/configuration'
+require 'jstp/version'
+
+require 'reader/jstp/engine'
+require 'reader/jstp/dispatch'
+require 'writer/jstp/dispatch'
 
-require 'writer/jstp/connector'
-require 'reader/jstp/connector'
+# Node for the JSTP protocol. Reference implementation in Ruby
+module JSTP
 
-class << self
-  include JSTP::API
+  # Configure the JSTP node. Usage:
+  #
+  #     JSTP.config do |config|
+  #       config.port :inbound => 33333, :outbound => 33333
+  #       config.strategy :inbound => :tcp, :outbound => :websocket
+  #       config.logger Logger.new $stdout
+  #       config.hostname `hostname` 
+  #       config.gateway true
+  #     end
+  def self.config &block
+    block.call Configuration.instance
+  end
 end

data/lib/jstp/configuration.rb

@@ -0,0 +1,68 @@
+module JSTP
+  class Configuration
+    include Singleton
+
+    def initialize
+      @port = SymbolMatrix :inbound => 33333, :outbound => 33333
+      @strategy = SymbolMatrix :inbound => :tcp, :outbound => :tcp
+      @logger = Logger.new $stdout
+      @hostname = (`hostname`)[0..-2]
+      @environment = :development
+      @gateway = true
+    end
+
+    def port argument = nil
+      @port = SymbolMatrix argument unless argument.nil?
+      @port
+    end
+
+    def port= argument
+      port argument
+    end
+
+    def strategy argument = nil
+      @strategy = SymbolMatrix argument unless argument.nil?
+      @strategy
+    end
+
+    def strategy= argument
+      strategy argument
+    end
+
+    def hostname argument = nil
+      @hostname = argument unless argument.nil?
+      @hostname
+    end
+
+    def hostname= argument
+      hostname argument
+    end
+
+    def logger argument = nil
+      @logger = argument unless argument.nil?
+      @logger
+    end
+
+    def logger= argument
+      logger argument
+    end
+
+    def gateway argument = nil
+      @gateway = argument unless argument.nil?
+      @gateway
+    end
+
+    def gateway= argument
+      gateway argument
+    end
+
+    def environment argument = nil
+      @environment = argument unless argument.nil?
+      @environment
+    end
+
+    def environment= argument
+      environment argument
+    end
+  end
+end

data/lib/jstp/controller.rb

@@ -1,17 +1,55 @@
 module JSTP
   class Controller
-    include JSTP::API
+    attr_reader :protocol, :method, :referer, :resource, :timestamp, :token, :original, :query, :body, :engine
     
-    def initialize message
-      @protocol = message["protocol"]
-      @method = message["method"]
-      @referer = message["referer"]
-      @timestamp = message["timestamp"]
-      @token = message["token"]
-      @resource = message["resource"]
-      @message = message
-      @response = message.clone
-      @response["body"] = {}
+    def initialize original, query, engine
+      @original = original
+      @engine = engine
+
+      @query = query
+
+      Configuration.instance.logger.info original.to.short
+    end
+
+    # Since it delegates Reader::Dispatch, the method is
+    # @param Method
+    # @param Resource
+    # @param Body
+    # @param Headers
+    def dispatch *args
+      @dispatch = Dispatch.new @original
+      @dispatch.referer = [Configuration.instance.hostname] + (self.class.to_s.split("::") - engine.class.to_s.split("::"))
+      @dispatch.from.array args
+
+      @dispatch
+    end
+
+    def protocol
+      original.protocol
+    end
+
+    def method
+      original.method
+    end
+
+    def referer
+      original.referer
+    end
+
+    def timestamp
+      original.timestamp
+    end
+
+    def token
+      original.token
+    end
+
+    def resource
+      original.resource
+    end
+
+    def body
+      original.body
     end
   end
 end

data/lib/jstp/dispatch.rb

@@ -0,0 +1,106 @@
+module JSTP
+  class Dispatch < Hash
+    include Discoverer::Writer
+    include Discoverer::Reader
+    
+    def initialize *args
+      
+      unless args.empty?
+        if args.length == 1
+          if args.first.is_a? Hash
+            from.hash args.first
+          elsif args.first.is_a? String
+            from.string args.first
+          elsif args.first.is_a? Symbol
+            self.method = args.first
+          end
+        else
+          from.array args
+        end
+      end
+
+      self["protocol"] = ["JSTP", "0.1"] unless self.has_key? "protocol"
+      self["timestamp"] = Time.now.to_i
+    end
+
+    def to_s
+      to.string
+    end
+
+    def method
+      self["method"]
+    end
+
+    def method= the_method
+      self["method"] = the_method.to_s.upcase
+    end
+
+    def resource
+      self["resource"]
+    end
+
+    def resource= the_resource
+      if the_resource.is_a? Array
+        self["resource"] = the_resource
+      elsif the_resource.is_a? String
+        self["resource"] = the_resource.split "/"
+      end
+    end
+
+    def protocol
+      self["protocol"]
+    end
+
+    def protocol= the_protocol
+      if the_protocol.is_a? Array
+        self["protocol"] = the_protocol
+      elsif the_protocol.is_a? String 
+        self["protocol"] = the_protocol.split "/"
+      end
+    end
+
+    def timestamp
+      self["timestamp"]
+    end
+
+    def timestamp= the_timestamp
+      if the_timestamp.is_a? Integer
+        self["timestamp"] = the_timestamp
+      elsif the_timestamp.is_a? Time
+        self["timestamp"] = the_timestamp.to_i
+      end
+    end
+
+    def referer
+      self["referer"]
+    end
+
+    def referer= the_referer
+      if the_referer.is_a? Array
+        self["referer"] = the_referer
+      elsif the_referer.is_a? String 
+        self["referer"] = the_referer.split "/"
+      end
+    end
+
+    def token
+      self["token"]
+    end
+
+    def token= the_token
+      if the_token.is_a? Array
+        self["token"] = the_token
+      elsif the_token.is_a? String 
+        self["token"] = the_token.split "/"
+      end
+    end     
+
+    def body
+      self["body"]
+    end
+
+    def body= the_body
+      self["body"] = the_body
+    end
+  end
+end

data/lib/jstp/engine.rb

@@ -1,28 +1,36 @@
 module JSTP
   class Engine
-    include Singleton
+    include Discoverer::Reader
+
+    def initialize test = false
+      @config = Configuration.instance
+      from.send @config.strategy.inbound unless test
+    end
     
     # Processes the dispatch in the new REST engine way
-    def dispatch message
+    def dispatch message, client
       host, the_class, query = discover_resource message["resource"].clone
-      resource = the_class.new message
-      if query.empty? && (message["body"].nil? || message["body"].empty?)
-        resource.send message["method"].downcase.to_sym
+      if @config.gateway && host != @config.hostname && host != 'localhost'
+        # May be we should gateway this message, if this wasn't aimed at us
+        message.to.send @config.strategy.outbound
       else
-        resource.send(
-          message["method"].downcase.to_sym, 
-          {
-            "body" => message["body"],
-            "query" => query
-          }
-        )
+        if the_class.ancestors.include? JSTP::Controller
+          resource = the_class.new message, query, self
+          resource.send message["method"].downcase.to_sym
+        else
+          if @config.environment == :development
+            raise NotAControllerError, "The resource class #{the_class} for #{message["resource"].join("/")} was found, but is not a JSTP::Controller"
+          else
+            raise NotPermittedError, "The selected resource is forbidden for this type of request"
+          end
+        end
       end
     end
 
     def discover_resource resource_stack
       response = []
       response << resource_stack.shift
-      class_stack = "::"
+      class_stack = "::#{self.class}::"
       query = []
       resource_stack.each do |item|
         begin
@@ -37,5 +45,61 @@ module JSTP
       response << query
       return response
     end
+
+    def clients
+      @clients ||= {}
+    end
+
+    class NotPermittedError < RuntimeError; end
+    class NotAControllerError < RuntimeError; end
+
+    # DSL for configuration
+    def self.port argument = nil
+      Configuration.instance.port argument
+    end
+
+    def self.port= argument
+      Configuration.instance.port = argument
+    end
+
+    def self.strategy argument = nil
+      Configuration.instance.strategy argument
+    end
+
+    def self.strategy= argument
+      Configuration.instance.strategy = argument
+    end
+
+    def self.logger argument = nil
+      Configuration.instance.logger argument
+    end
+
+    def self.logger= argument
+      Configuration.instance.logger = argument
+    end
+
+    def self.hostname argument = nil
+      Configuration.instance.hostname argument
+    end
+
+    def self.hostname= argument
+      Configuration.instance.hostname = argument
+    end
+
+    def self.environment argument = nil
+      Configuration.instance.environment argument
+    end
+
+    def self.environment= argument
+      Configuration.instance.environment = argument
+    end
+
+    def self.gateway argument = nil
+      Configuration.instance.gateway argument
+    end
+
+    def self.gateway= argument
+      Configuration.instance.gateway = argument
+    end
   end
 end