siffer 0.0.4

data/lib/protocol.rb

@@ -0,0 +1,159 @@
+module Siffer
+  # The Protocol module deals with the transport validation. Provides
+  # constants for HTTP statuses as well as acceptable paths for Siffer
+  # Servers and Agents.
+  module Protocol
+    
+    include Siffer::Messages
+    include Siffer::Messaging
+    
+    class UnknownPath < Exception; end #:nodoc:
+    class NonPostRequest < Exception; end #:nodoc:
+    
+    # Checks the incoming request against the following protocol constraints:
+    # * 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"]})
+      end
+    end
+    
+    # Validates the request object against the Acceptable Paths (Siffer spec)
+    # and that the request is a POST.
+    def check_path_against_protocol
+      unless ACCEPTABLE_PATHS.has_value? @request.path_info
+        raise UnknownPath
+      end
+      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
+    end
+    
+    # Provides a context for each request. Creates the @request, @response and
+    # @original objects to use throughout the call. 
+    # Validates against Protocol as well as Messaging using #request_failed 
+    # predicates respectively.
+    #
+    # Yields the block if provided to allow further processing. 
+    #
+    #Finishes by calling #finish on the response object or returns the generic
+    # response message.
+    def with_each_request(env, &block)
+      @request = Request.new(env)
+      unless request_failed_protocol? or request_failed_messaging?
+        using_message_from @request do # possibly a concurrency issue here
+          yield if block_given?
+        end
+      end
+      @response.finish unless no_response_available
+    end
+
+    # Sets the @response to a Siffer::Messages::Ack message with the 
+    # appropriate Error category and code. Optional description is allowed
+    # and placed in the ExtendedDesc node.
+    def error_response(category,code, desc = nil)
+      error = Error.new(category,code,desc)
+      ack = Ack.new(self.name, @request.original, :error => error)
+      @response = Response.new(ack)
+    end
+
+    # Determines if there is a response instance created. If not
+    # it creates one with an Ack/Error describing not having 
+    # anything to process.
+    def no_response_available
+      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.
+ERR
+        !error_response(12,1,err)
+      end
+    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.
+    ACCEPTABLE_PATHS = {
+      :root => "/",
+      :ping => "/ping",
+      :status => "/status",
+      :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.
+    HTTP_STATUS_CODES = {
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      300  => 'Multiple Choices',
+      301  => 'Moved Permanently',
+      302  => 'Moved Temporarily',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      400  => 'Bad Request',
+      401  => 'Unauthorized',
+      402  => 'Payment Required',
+      403  => 'Forbidden',
+      404  => 'Not Found',
+      405  => 'Method Not Allowed',
+      406  => 'Not Acceptable',
+      407  => 'Proxy Authentication Required',
+      408  => 'Request Time-out',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Large',
+      415  => 'Unsupported Media Type',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Time-out',
+      505  => 'HTTP Version not supported'
+    }
+  
+  end
+end

data/lib/registration.rb

@@ -0,0 +1,87 @@
+module Siffer
+  # The Registration module manages Register message types and processes
+  # registration requests.
+  module Registration
+
+    include Siffer::Messages
+
+    class AgentNotRegistered < Exception #:nodoc:
+    end
+    
+    # The request (message) is processed for registration requests.
+    def process_registration
+      begin
+        check_for_registration
+        register
+      rescue AgentNotRegistered
+        error_response(4,9)
+      end
+    end
+    
+    # Parses the request body with RequestBody to determine if the 
+    # the request is a registration message. If it is or if the 
+    # source is already registered it passes through, otherwise raises
+    # AgentNotRegistered exception.
+    def check_for_registration 
+      unless register? or registered?(@request.message.source_id)
+        raise AgentNotRegistered
+      end
+    end
+    
+    # Process the message for registration by validating:
+    # * source_id
+    # * permissions to register with ZIS
+    # * version compatibility
+    # * buffer size compatibility
+    # 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?
+        @registration = Register.parse(@request.body)
+        validate_source_id
+        validate_permission
+        validate_version
+        validate_max_buffer_size
+        # ignore the fact we haven't stored away any registration information !!!!!!
+        # ignore the fact we haven't even built a data model for objects and permissions for the acl !!!!!
+        ack = Ack.new(name, @request.original, :status => Status.success(Acl.new))
+        @response = Response.new(ack)
+      end
+    end
+    
+    # We may not do anything here - will we pre-permit sources to register?
+    # We could possibly call the Central Admin to qualify the source there?
+    def validate_source_id
+    end
+    
+    
+    # We need to check for permissions previously assigned for this
+    # agent (possibly from Central Admin).
+    def validate_permission
+    end
+    
+    # Currently only validating that the registration version matches
+    # identically to the SIF version implemented by Siffer.
+    # TODO: This will need refinement to provide broader version support.
+    def validate_version
+      if @registration.version != Siffer.sif_version
+        error_response(5,4,"Unsupported version: #{@registration.version}")
+      end
+    end
+    
+    # Validates the registration buffer size is greater than the 
+    # minimum buffer set by the ZIS.
+    def validate_max_buffer_size
+      if @registration.max_buffer < min_buffer
+        error_response(5,6)
+      end
+    end
+    
+    # Returns true if the agent is included in the list of Agents
+    # previously registered.
+    def registered?(agent)
+      agents.has_key? agent
+    end
+    
+  end
+end

data/lib/request.rb

@@ -0,0 +1,25 @@
+module Siffer
+  
+  # Request represents each message received by the Server or Agent in Siffer.
+  class Request < Rack::Request
+    
+    # Constructor will assure that #message is always populated with the body
+    # of the request for easy access throughout the call.
+    def initialize(env)
+      env["CONTENT_TYPE"] ||= Siffer::Messaging::MIME_TYPES["appxml"]
+      super(env)
+    end
+    
+    # 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
+    
+  end
+  
+end

data/lib/request_logger.rb

@@ -0,0 +1,31 @@
+module Siffer
+  class RequestLogger
+    def initialize(app, log=nil)
+      @app = app
+      @log = log || STDERR
+    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)
+      @app.call(env)
+    end
+    
+    def log_request
+      @now = Time.now
+      message = Siffer::Messages::RequestBody.parse(@msg)
+      @log << %{%s request made by %s on %s at %s\n} %
+        [
+         message.type,
+         @env["REMOTE_USER"],
+         @now.strftime("%b/%d/%Y"),
+         @now.strftime("%H:%M:%S")
+        ]
+    end
+ 
+  end
+end

data/lib/response.rb

@@ -0,0 +1,26 @@
+module Siffer
+  
+  class Response < Rack::Response
+    
+     def initialize(body=[], status=200, header={}, &block)
+       header["Content-Type"] ||= Siffer::Messaging::MIME_TYPES["appxml"]
+       super(body,status,header,&block)
+     end
+     
+     def self.from(url,data)
+       uri = URI.parse(url)
+       begin
+         response = Net::HTTP.start(uri.host,uri.port) { |http|
+           post = Net::HTTP::Post.new(uri.path, {})
+           post.body = (data.respond_to?("read")) ? data.read : data
+           post.content_type = Siffer::Messaging::MIME_TYPES["appxml"]
+           http.request(post)
+         }
+         Response.new(response.body,response.code.to_i,response.header.to_hash)
+       rescue Errno::ECONNREFUSED => e
+         Response.new(e.message, 500, {})
+       end
+     end
+  end
+  
+end

data/lib/server.rb

@@ -0,0 +1,40 @@
+module Siffer
+
+  # Zone Integration Server
+  # Facilitates communication between Agents. Acts as a central point
+  # where Agents can send their events/requests and receive the response
+  # from other Agents. 
+  class Server
+    include Siffer::Protocol
+    include Siffer::Registration
+    
+    attr_reader :name, :host, :port, :min_buffer, :agents
+    
+    ## options Parameter
+    # name = The name of the ZIS
+    # host = The host this instance is started on
+    # port = The port to connect to this ZIS
+    # admin = The administration site managing this ZIS
+    # min_buffer = The minimum buffer size this ZIS will facilitate
+    def initialize(options = {})
+      raise ArgumentError, "Administration URL required" unless options.include? "admin"
+      @name = options["name"] || "Default Server"
+      @host = options["host"] || "localhost"
+      @port = options["port"] || 8300
+      @min_buffer = options["min_buffer"] || 1024
+      @agents = {}
+    end
+    
+    # Process the request with all the SIF protocols
+    def call(env)
+      with_each_request(env) do
+         process_registration
+          # process_provision
+          # process_subscription
+          # process_event
+      end
+    end
+          
+  end
+
+end

data/lib/siffer.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'uuid'
+require 'rack'
+require 'builder'
+require 'net/http'
+require 'net/https'
+require 'rexml/document'
+require 'hpricot'
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+module Siffer
+
+    VENDOR = "h3o(software)" unless defined?(Siffer::VENDOR)
+    VERSION = [0,0,4] 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)
+  
+    # The vendor of this SIF implementation (self describing for Agents)
+    def self.vendor() VENDOR end
+      
+    # The version of the h3o(software) SIF implementation
+    def self.version() VERSION.join(".") end
+  
+    # The version of SIF being implemented - based on the specification
+    def self.sif_version() SIF_VERSION.join(".") end
+    
+    # The SIF XML namespace to be used across this implementation
+    def self.sif_xmlns() SIF_XMLNS end
+  
+    # The root directory that the SIF implementation is running from
+    def self.root() @root ||= Dir.pwd end
+    def self.root=(value) @root = value end
+      
+end
+
+Siffer.autoload :Messages, "messages"
+Siffer.autoload :Protocol, "protocol"
+Siffer.autoload :Messaging, "messaging"
+Siffer.autoload :Registration, "registration"
+
+%w(server agent response request container request_logger).each do |component|
+  require component
+end

data/spec/agent_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require 'webrick'
+
+describe Siffer::Agent do
+  it "should instantiate with default host, port, name" do
+    agent = Siffer::Agent.new("servers" => 'none', "admin" => 'none')
+    agent.host.should == "localhost"
+    agent.port.should == 8300
+    agent.name.should == "Default Agent"
+  end
+  
+  it "should allow defaults to be overriden" do
+    agent = Siffer::Agent.new("admin" => 'none',
+                              "servers" => 'none', 
+                              "name" => "name",
+                              "host" => "test",
+                              "port" => 222)
+    agent.host.should == "test"
+    agent.name.should == "name"
+    agent.port.should == 222
+  end
+  
+  it "should require a server url to register with" do
+    lambda {
+      agent = Siffer::Agent.new 
+      }.should raise_error("Server URL(s) required")
+  end
+  
+  it "should require an admin URL" do
+    lambda {
+      agent = Siffer::Agent.new("servers" => "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.wake_up
+      agent.should be_registered
+    end
+  end
+  
+  it "should be unregistered by default" do
+    agent = Siffer::Agent.new("admin" => 'none', "servers" => 'none')
+    agent.should_not be_registered
+  end
+  
+end