siffer 0.0.4 → 0.0.5

data/lib/siffer.rb

@@ -12,7 +12,7 @@ $: << File.expand_path(File.dirname(__FILE__))
 module Siffer
 
     VENDOR = "h3o(software)" unless defined?(Siffer::VENDOR)
-    VERSION = [0,0,4] unless defined?(Siffer::VERSION)
+    VERSION = [0,0,5] unless defined?(Siffer::VERSION)
     SIF_VERSION = [2,2,0] unless defined?(Siffer::SIF_VERSION)
     SIF_XMLNS = "http://www.sifinfo.org/infrastructure/2.x" unless defined?(Siffer::SIF_XMLNS)
   
@@ -34,11 +34,11 @@ module Siffer
       
 end
 
-Siffer.autoload :Messages, "messages"
-Siffer.autoload :Protocol, "protocol"
-Siffer.autoload :Messaging, "messaging"
-Siffer.autoload :Registration, "registration"
+Siffer.autoload :Messages, "siffer/messages"
+Siffer.autoload :Protocol, "siffer/protocol"
+Siffer.autoload :Messaging, "siffer/messaging"
+Siffer.autoload :Registration, "siffer/registration"
 
 %w(server agent response request container request_logger).each do |component|
-  require component
+  require "siffer/#{component}"
 end

data/lib/{agent.rb → siffer/agent.rb}

@@ -7,8 +7,8 @@ module Siffer
     attr_reader :name, :host, :port, :admin, :server
     
     def initialize(options = {})
-      raise "Server URL(s) required" unless options.include? "servers"
-      @server = options["servers"]
+      raise "Zone Integration Server URL required" unless options.include? "server"
+      @server = options["server"]
       raise "Administration URL required" unless options.include? "admin"
       @admin = options["admin"]
       @name = options["name"] || "Default Agent"
@@ -19,7 +19,9 @@ module Siffer
     
     def call(env)
       with_each_request(env) do
-        
+        #process_event
+        #process_request
+        #process_response
       end
     end
 

data/lib/{container.rb → siffer/container.rb}

@@ -14,7 +14,8 @@ module Siffer
                   Siffer::Agent.new(config["agent"]) : 
                   Siffer::Server.new(config["server"])
       @name = config[type]["name"]
-      @host = config[type]["host"]
+      uri = URI.parse(config[type]["host"])
+      @host = uri.host.nil? ? uri.to_s : uri.host
       @port = config[type]["port"]
       @daemonize = options[:daemonize]
       @pid = options[:pid]
@@ -28,10 +29,7 @@ module Siffer
     def run
       daemonize
       server = best_available_server
-      options = {
-        :Host => host,
-        :Port => port
-      }
+      options = { :Host => host, :Port => port }
       component.wake_up if component.respond_to?("wake_up")
       app = component_wrapped_in_environment
       server.run app, options

data/lib/siffer/messages.rb

@@ -0,0 +1,7 @@
+require 'siffer/messages/error'
+require 'siffer/messages/status'
+require 'siffer/messages/acl'
+require 'siffer/messages/request_body'
+require 'siffer/messages/message'
+require 'siffer/messages/ack'
+require 'siffer/messages/register'

data/lib/{messaging.rb → siffer/messaging.rb}

@@ -31,9 +31,9 @@ module Siffer
          @response = Response.new(Siffer::Protocol::HTTP_STATUS_CODES[406],
                       406,
                       {"Content-Type" => MIME_TYPES["htm"]})
-      rescue MalformedXml; error_response(1,2);
-      rescue MalformedSIFMessage; error_response(12,2);
-      rescue VersionMismatch; error_response(12,3);
+      rescue MalformedXml; error_response(1,2,"There was no XML body to parse.");
+      rescue MalformedSIFMessage; error_response(12,2,"The XML was not a recognizable SIF Message.");
+      rescue VersionMismatch; error_response(12,3,"The SIF version did not match supported versions.");
       rescue XmlNsMismatch; error_response(1,4,"XMLNS not compatible with SIF")
       end
     end
@@ -48,7 +48,9 @@ module Siffer
     # BadContentType exception.
     def check_content_type
       content_type = @request.content_type
-      unless [MIME_TYPES["xml"], MIME_TYPES["appxml"]].include? content_type
+      unless [MIME_TYPES["xml"], 
+              MIME_TYPES["appxml"], 
+              MIME_TYPES["appxmlencoded"]].include? content_type
         raise BadContentType
       end
     end
@@ -86,7 +88,8 @@ module Siffer
   
     # MIME Types used in Siffer
     MIME_TYPES = {
-      "appxml" => "application/xml;charset=utf-8", 
+      "appxmlencoded" => "application/xml;charset=utf-8", 
+      "appxml" => "application/xml",
       "htm"   => "text/html",
       "html"  => "text/html",
       "xml"   => "text/xml"

data/lib/{protocol.rb → siffer/protocol.rb}

@@ -14,18 +14,22 @@ module Siffer
     # * Unknown PATH
     # * Non-POST request
     def request_failed_protocol?
-      begin
-        check_path_against_protocol
-      rescue UnknownPath
-        # TODO: Make a better Not Found response
-        @response = Response.new(HTTP_STATUS_CODES[404],
-                      404,
-                      {"Content-Type" => Siffer::Messaging::MIME_TYPES["htm"]})
-      rescue NonPostRequest
-        # TODO: Make a better Method Not Allowed response
-        @response = Response.new(HTTP_STATUS_CODES[405],
-                      405,
-                      {"Content-Type" => Siffer::Messaging::MIME_TYPES["htm"]})
+      if @request.get? and @request.path_info == ACCEPTABLE_PATHS[:root]
+        root_response
+      else
+        begin
+          check_path_against_protocol
+        rescue UnknownPath
+          # TODO: Make a better Not Found response
+          @response = Response.new(HTTP_STATUS_CODES[404],
+                        404,
+                        {"Content-Type" => MIME_TYPES["htm"]})
+        rescue NonPostRequest
+          # TODO: Make a better Method Not Allowed response
+          @response = Response.new(HTTP_STATUS_CODES[405],
+                        405,
+                        {"Content-Type" => MIME_TYPES["htm"]})
+        end
       end
     end
     
@@ -35,14 +39,14 @@ module Siffer
       unless ACCEPTABLE_PATHS.has_value? @request.path_info
         raise UnknownPath
       end
-      unless @request.post? 
+      unless @request.post?
         raise NonPostRequest
       end
     end
     
     # Returns the URI of the component (Server or Agent)
     def uri
-       URI.parse("http://#{host}:#{port}").to_s
+       URI.parse("http://#{host.gsub(/(http|https):\/\//,"")}:#{port}").to_s
     end
     
     # Provides a context for each request. Creates the @request, @response and
@@ -80,21 +84,32 @@ module Siffer
       if @response.nil?
         err = <<"ERR"
 You are receiving this message because you failed to 
-provide enough information to respond to. This is likely due
-to the message type missing (i.e. Register,Provide) or possibly
-not enough information to process effectively. Please check the 
-message you are sending and resend after any corrections.
+provide enough information to respond to. This message 
+went completely through the messaging stack and
+failed to instigate a response.
+ 
+Please check the message you are sending and resend after 
+any corrections.
 ERR
         !error_response(12,1,err)
       end
     end
+    
+    def root_response
+      html = <<"HTML"
+<html>
+  <body>
+    <h1>Siffer Endpoint</h1>
+    <p>You have reached a Siffer component.</p>
+  </body>
+</html>
+HTML
+      @response = Response.new(html,200,{"Content-Type" => MIME_TYPES["htm"]})
+    end
         
     # Paths that comply with the messaging protocol determined
     # by the SIF Specification. These are Siffer specific and not
-    # spelled out in SIF Specification (rather implied). Each path
-    # will generate it's own predicate method (i.e. #ping?) that can
-    # be used to determine the requests path based on the content of the
-    # message or the path-info of the request.
+    # spelled out in SIF Specification (rather implied). 
     ACCEPTABLE_PATHS = {
       :root => "/",
       :ping => "/ping",
@@ -102,16 +117,6 @@ ERR
       :register => "/register"
     }
     
-    ACCEPTABLE_PATHS.each do |name,path|
-      define_method("#{name.to_s}?") do
-        @request.message.type.downcase == name.to_s
-        # The difference in these lines is the difference between allowing
-        # any message to come through any PATH or forcing PATH and message
-        # to match. What is better?
-        # TODO: Decide on protocol validations !
-        #@request.path_info == path || req_body.type.downcase == name.to_s
-      end
-    end
     
     # Every standard HTTP code mapped to the appropriate message.
     # Stolen from Mongrel.

data/lib/{registration.rb → siffer/registration.rb}

@@ -23,7 +23,7 @@ module Siffer
     # source is already registered it passes through, otherwise raises
     # AgentNotRegistered exception.
     def check_for_registration 
-      unless register? or registered?(@request.message.source_id)
+      unless @request.register? or registered?(@request.message.source_id)
         raise AgentNotRegistered
       end
     end
@@ -36,7 +36,7 @@ module Siffer
     # If all validations pass the registration is stored by the ZIS and
     # the agent is added to the list of agents available to the zone.
     def register
-      if register?
+      if @request.register?
         @registration = Register.parse(@request.body)
         validate_source_id
         validate_permission

data/lib/siffer/request.rb

@@ -0,0 +1,28 @@
+module Siffer
+  
+  # Request represents each message received by the Server or Agent in Siffer.
+  class Request < Rack::Request
+    
+    # Provides access to the request message in Siffer::Messages::Message 
+    # format.
+    def message
+      if body.is_a?(StringIO) && body.pos == body.length
+        body.rewind
+      end
+      Siffer::Messages::RequestBody.parse(body)
+    end
+    alias :original :message
+    
+    Siffer::Protocol::ACCEPTABLE_PATHS.each do |name,path|
+      define_method("#{name.to_s}?") do
+        message.type.downcase == name.to_s
+        # The difference in these lines is the difference between allowing
+        # any message to come through any PATH or forcing PATH and message
+        # to match. What is better?
+        # TODO: Decide on protocol validations !
+        #@request.path_info == path || req_body.type.downcase == name.to_s
+      end
+    end
+  end
+  
+end

data/lib/{request_logger.rb → siffer/request_logger.rb}

@@ -6,22 +6,23 @@ module Siffer
     end
 
     def call(env)
-      @env = env
-      # Maybe there is a better way to pick the body of the input
-      # instead of reading it then stuffing it back in ??
       @msg = env["rack.input"].read
       log_request
-      env["rack.input"] = StringIO.new(@msg)
+      env["rack.input"].rewind
       @app.call(env)
     end
     
     def log_request
       @now = Time.now
-      message = Siffer::Messages::RequestBody.parse(@msg)
+      message = Siffer::Messages::RequestBody.parse(@msg).type rescue "Unknown"
+      host = Siffer::Messages::RequestBody.parse(@msg).source_id rescue "Unknown Source"
+      if host.nil? or host == "" 
+        host = "Unknown Source"
+      end
       @log << %{%s request made by %s on %s at %s\n} %
         [
-         message.type,
-         @env["REMOTE_USER"],
+         message,
+         host,
          @now.strftime("%b/%d/%Y"),
          @now.strftime("%H:%M:%S")
         ]

data/lib/{response.rb → siffer/response.rb}

@@ -3,7 +3,7 @@ module Siffer
   class Response < Rack::Response
     
      def initialize(body=[], status=200, header={}, &block)
-       header["Content-Type"] ||= Siffer::Messaging::MIME_TYPES["appxml"]
+       header["Content-Type"] ||= Siffer::Messaging::MIME_TYPES["appxmlencoded"]
        super(body,status,header,&block)
      end
      

data/lib/{server.rb → siffer/server.rb}

@@ -29,9 +29,11 @@ module Siffer
     def call(env)
       with_each_request(env) do
          process_registration
-          # process_provision
-          # process_subscription
-          # process_event
+          # process_provision       MAYBE SAME MODULE
+          # process_subscription    MAYBE SAME MODULE
+          # process_event (server process not agent)    REDIRECTS
+          # process_request (server process not agent)  REDIRECTS
+          # process_response (server process not agent) REDIRECTS
       end
     end
           

data/spec/agent_spec.rb

@@ -3,7 +3,7 @@ require 'webrick'
 
 describe Siffer::Agent do
   it "should instantiate with default host, port, name" do
-    agent = Siffer::Agent.new("servers" => 'none', "admin" => 'none')
+    agent = Siffer::Agent.new("server" => 'none', "admin" => 'none')
     agent.host.should == "localhost"
     agent.port.should == 8300
     agent.name.should == "Default Agent"
@@ -11,7 +11,7 @@ describe Siffer::Agent do
   
   it "should allow defaults to be overriden" do
     agent = Siffer::Agent.new("admin" => 'none',
-                              "servers" => 'none', 
+                              "server" => 'none', 
                               "name" => "name",
                               "host" => "test",
                               "port" => 222)
@@ -23,30 +23,25 @@ describe Siffer::Agent do
   it "should require a server url to register with" do
     lambda {
       agent = Siffer::Agent.new 
-      }.should raise_error("Server URL(s) required")
+      }.should raise_error("Zone Integration Server URL required")
   end
   
   it "should require an admin URL" do
     lambda {
-      agent = Siffer::Agent.new("servers" => "none")
+      agent = Siffer::Agent.new("server" => "none")
     }.should raise_error("Administration URL required")
   end
   
-  it "should respond to uri" do
-    agent = Siffer::Agent.new("admin" => 'none', "servers" => 'none')
-    agent.uri.should == "http://localhost:8300"
-  end
-  
   it "should register with server(s) on wake-up" do
     with_fake_server(Siffer::Server.new("admin" => "none")) do |url|
-      agent = Siffer::Agent.new("admin" => 'none', "servers" => url)
+      agent = Siffer::Agent.new("admin" => 'none', "server" => url)
       agent.wake_up
       agent.should be_registered
     end
   end
   
   it "should be unregistered by default" do
-    agent = Siffer::Agent.new("admin" => 'none', "servers" => 'none')
+    agent = Siffer::Agent.new("admin" => 'none', "server" => 'none')
     agent.should_not be_registered
   end
   

data/spec/container_spec.rb

@@ -29,7 +29,7 @@ describe Siffer::Container, "options" do
           "host" => 'localhost',
           "port" => 8200,
           "admin" => 'http://localhost:3000/',
-          "servers" => 'http://localhost:4001/'
+          "server" => 'http://localhost:4001/'
         }
       }
     }
@@ -88,7 +88,7 @@ describe Siffer::Container, "runtime" do
           "host" => 'localhost',
           "port" => 8210,
           "admin" => 'http://localhost:3000/',
-          "servers" => 'http://localhost:4001/'
+          "server" => 'http://localhost:4001/'
         }
       }
     }

data/spec/default_agent

@@ -2,5 +2,5 @@ agent:
   name: 'Clints Agent'
   host: 'localhost'
   port: 4002
-  servers: 'http://localhost:4001/'
+  server: 'http://localhost:4001/'
   admin: 'http://localhost:3000'

data/spec/messaging_spec.rb

@@ -8,11 +8,8 @@ require File.join(File.dirname(__FILE__),"spec_helper")
   # Stage the component a little bit:
   #    Agents require Servers
   #    Both require central-admin 
-  component = component.new("admin" => 'none', "servers" => '')
-  msg = Siffer::Messages::Message.new("source")
-  msg.content do |xml|
-    xml.SIF_BogusType
-  end
+  component = component.new("admin" => 'none', "server" => '')
+  msg = Siffer::Messages::Message.new("source").content{|xml| xml.SIF_Bogus}
   
   describe component, "Messaging - response" do
     it "should always return Ack for proper SIF_Messages" do
@@ -25,7 +22,7 @@ require File.join(File.dirname(__FILE__),"spec_helper")
   describe component, "Messaging - content-type" do
     it "should always respond with application/xml" do
       for_every_path(:on => component, :input => msg) do |res|
-        res.content_type.should == Siffer::Messaging::MIME_TYPES["appxml"]
+        res.content_type.should == Siffer::Messaging::MIME_TYPES["appxmlencoded"]
       end
     end
     

data/spec/protocol_spec.rb

@@ -5,12 +5,8 @@ require File.join(File.dirname(__FILE__), "spec_helper")
   # Stage the component a little bit:
   #    Agents require Servers
   #    Both require central-admin 
-  component = component.new("admin" => 'none', "servers" => '')
-  # setup messages to use for mock requests 
-  ping = "<SIF_Message><SIF_SystemControl><SIF_Ping /></SIF_SystemControl></SIF_Message>"
-  status = "<SIF_Message><SIF_SystemControl><SIF_Status /></SIF_SystemControl></SIF_Message>"
-  register = "<SIF_Message><SIF_Register /></SIF_Message>"
-
+  component = component.new("admin" => 'none', "server" => '')
+  
   describe component, "Protocol - /unknown_path" do
     it "should return 404" do
       res = Rack::MockRequest.new(component).post("/bad_path")
@@ -18,32 +14,37 @@ require File.join(File.dirname(__FILE__), "spec_helper")
     end
   end
   
-  describe component, "Protocol - Accepted Paths" do
+  describe component, "Protocol - Accepted Paths except Root URL" do
     it "should only allow POST method" do
       Siffer::Protocol::ACCEPTABLE_PATHS.each do |name,path|
-        res = Rack::MockRequest.new(component).get(path)
-        res.should be_client_error
-      end
-    end
-    
-    it "should be identified by predicate through body" do
-      Siffer::Protocol::ACCEPTABLE_PATHS.each do |name,path|
-        unless name == :root
-          component.call({"rack.input" => eval(name.to_s)})
-          component.should eval("be_#{name.to_s}")
+        if(path != "/")
+          res = Rack::MockRequest.new(component).get(path)
+          res.should be_client_error
         end
       end
     end
+  end
+  
+  describe component, "Protocol - Root URL on GET" do
+    it "should display component info" do
+      res = Rack::MockRequest.new(component).get("/")
+      res.should be_ok
+      res.body.should match(/<h1>Siffer Endpoint<\/h1>/)
+    end
+  end
+  
+  describe component, "Protocol - URI" do
     
-    it "should be identified by predicate through path-info" do
-      Siffer::Protocol::ACCEPTABLE_PATHS.each do |name,path|
-        unless name == :root
-          component.call({
-            "rack.input" => "<SIF_Message><SIF_#{name.to_s} /></SIF_Message>", 
-            "PATH_INFO" => path})
-          component.should eval("be_#{name.to_s}")
-        end
-      end
+    it "should respond to uri" do
+      component.uri.should == "http://localhost:8300"
+    end
+
+    it "should respond to full url in uri" do
+      component = component.class.new("admin" => "none", 
+                                      "server" => "", 
+                                      "host" => "http://localhost")
+      component.uri.should == "http://localhost:8300"
     end
   end
+  
 end