siffer 0.0.5 → 0.0.7

data/lib/siffer/messages/error.rb

@@ -1,174 +0,0 @@
-module Siffer
-  module Messages
-    class Error
-      
-      attr_reader :category, :code, :description
-      
-      def initialize(category, code, desc = nil)
-        @category = CATEGORY[category]
-        @category_index = category
-        @code = CODE[@category][code]
-        @code_index = code
-        @description = desc
-      end
-      
-      def read
-        xml = Builder::XmlMarkup.new
-        xml.SIF_Error { |error|
-          error.SIF_Category(@category_index)
-          error.SIF_Code(@code_index)
-          error.SIF_Desc(@code)
-          error.SIF_ExtendedDesc(@description) unless @description.nil?
-        }
-      end
-      alias :to_str :read
-  
-      
-      # Categories of Errors specified by SIF
-      CATEGORY = [
-        "Unknown (This should NEVER be used if possible)",
-        "XML Validation",
-        "Encryption",
-        "Authentication",
-        "Access and Permissions",
-        "Registration",
-        "Provision",
-        "Subscription",
-        "Request and Response",
-        "Event Reporting and Processing",
-        "Transport",
-        "System (OS, Database, Vendor localized, etc.)",
-        "Generic Message Handling",
-        "SMB Handling"
-      ]
-      
-      # Codes related to CATEGORY
-      # Some codes are blank to match the SIF Spec
-      CODE = {
-        CATEGORY[1] => [ # Xml Validation
-          "",
-          "Generic error",
-          "Message is not well-formed",
-          "Generic validation error",
-          "Invalid value for element/attribute",
-          "",
-          "Missing mandatory element/attribute"
-          ],
-        CATEGORY[2] => [ # Encryption
-          "",
-          "Generic error"
-          ],
-        CATEGORY[3] => [ # Authentication
-          "",
-          "Generic error",
-          "Generic authentication error (with signature)",
-          "Missing sender's certificate",
-          "Invalid certificate",
-          "Sender's certificate is not trusted",
-          "Expired certificate",
-          "Invalid signature",
-          "Invalid encryption algorithm (only accepts MD4)",
-          "Missing public key of the receiver (when decrypting message)", 
-          "Missing receiver's private key (when decrypting message)"
-          ],
-        CATEGORY[4] => [ # Access and Permissions
-          "",
-          "Generic error",
-          "No permission to register",
-          "No permission to provide this object",
-          "No permission to subscribe to this SIF_Event",
-          "No permission to request this object",
-          "No permission to respond to this object request", 
-          "No permission to publish SIF_Event",
-          "No permission to administer policies",
-          "SIF_SourceId is not registered",
-          "No permission to publish SIF_Event Add",
-          "No permission to publish SIF_Event Change",
-          "No permission to publish SIF_Event Delete"
-          ],
-        CATEGORY[5] => [ # Registration
-          "",
-          "Generic error",
-          "The SIF_SourceId is invalid",
-          "Requested transport protocol is unsupported", 
-          "Requested SIF_Version(s) not supported",
-          "",
-          "Requested SIF_MaxBufferSize is too small", 
-          "ZIS requires a secure transport",
-          "",
-          "Agent is registered for push mode (returned when a push-mode agent sends a SIF_GetMessage)", 
-          "ZIS does not support the requested Accept-Encoding value"    
-          ],
-        CATEGORY[6] => [ # Provision
-          "",
-          "Generic error",
-          "",
-          "Invalid object", 
-          "Object already has a provider (SIF_Provide message)"
-          ],
-        CATEGORY[7] => [ # Subscription
-          "",
-          "Generic error",
-          "",
-          "Invalid object"
-          ],
-        CATEGORY[8] => [ # Request and Response
-          "",
-          "Generic error",
-          "",
-          "Invalid object",
-          "No provider",
-          "",
-          "",
-          "Responder does not support requested SIF_Version",
-          "Responder does not support requested SIF_MaxBufferSize",
-          "Unsupported query in request",
-          "Invalid SIF_RequestMsgId specified in SIF_Response",
-          "SIF_Response is larger than requested SIF_MaxBufferSize",
-          "SIF_PacketNumber is invalid in SIF_Response",
-          "SIF_Response does not match any SIF_Version from SIF_Request",
-          "SIF_DestinationId does not match SIF_SourceId from SIF_Request", 
-          "No support for SIF_ExtendedQuery",
-          "SIF_RequestMsgId deleted from cache due to timeout",
-          "SIF_RequestMsgId deleted from cache by administrator",
-          "SIF_Request cancelled by requesting agent"
-          ],
-        CATEGORY[9] => [ # Event Reporting and Processing
-          "",
-          "Generic error",
-          "", 
-          "Invalid event"
-          ],
-        CATEGORY[10] => [ # Transport
-          "",
-          "Generic error",
-          "Requested protocol is not supported",
-          "Secure channel requested and no secure path exists", 
-          "Unable to establish connection"
-          ],
-        CATEGORY[11] => [ # System
-          "",
-          "Generic Error"
-          ],
-        CATEGORY[12] => [ # Generic Message Handling
-          "",
-          "Generic error",
-          "Message not supported",
-          "Version not supported",
-          "Context not supported",
-          "Protocol error",
-          "No such message (as identified by SIF_OriginalMsgId)", 
-          "Multiple contexts not supported"
-          ],
-        CATEGORY[13] => [ # SMB Handling
-          "",
-          "Generic error",
-          "SMB can only be invoked during a SIF_Event acknowledgement", 
-          "Final SIF_Ack expected from Push-Mode Agent",
-          "Incorrect SIF_MsgId in final SIF_Ack"
-          ]
-      }
-      
-    end
-  end
-end

data/lib/siffer/messages/request_body.rb

@@ -1,66 +0,0 @@
-module Siffer
-  
-  module Messages
-    
-    # This class is used to parse the SIF Message information
-    # out of the Request Body. It parses enough information to redirect
-    # to other processes. It does not parse details of the Message such as
-    # Protocol if a Register message, or Error if an Ack message. Each 
-    # message type will inherit this class in order to provide a #parse
-    # method that will allow access to those specific attributes.
-    # It provides access to:
-    # * source_id
-    # * msg_id
-    # * type
-    class RequestBody
-      
-      def initialize(xml_string)
-        @xml = xml_string
-        @doc = Hpricot(@xml, :xml => true)
-      end
-      
-      # Will return the name of the element found just inside the root
-      # or just inside SIF_SystemControl if present. 
-      def type
-        begin
-          msg_type = (@doc/:SIF_Message).first.children[0].name
-          if msg_type == "SIF_SystemControl"
-            msg_type = (@doc/:SIF_Message/:SIF_SystemControl).first.children[0].name
-          end
-          drop_sif msg_type
-        rescue
-          raise "Failed to parse #{@xml} for SIF Type"
-        end
-      end
-      
-      # The SIF_SourceId from the SIF_Header
-      def source_id
-        (@doc/"//SIF_Header/SIF_SourceId/").text
-      end
-      
-      # The SIF_MsgId from the SIF_Header
-      def msg_id
-        (@doc/"//SIF_Header/SIF_MsgId/").text
-      end
-      
-      # Parses the xml provided and returns a RequestBody.
-      # Xml must respond to read or be a String.
-      def self.parse(xml)
-        unless xml.respond_to?("read") or xml.is_a?(String)
-          raise ArgumentError, "Unable to read Xml" 
-        end
-        xml = xml.read if xml.respond_to?("read")
-        self.new(xml) # use self because we are going to inherit this class
-      end
-      
-      private
-        # Drops the SIF_ from the front of the string provided
-        def drop_sif(string)
-          string.gsub!("SIF_","")
-        end
-      
-    end
-    
-  end
-  
-end

data/lib/siffer/messages/status.rb

@@ -1,55 +0,0 @@
-module Siffer
-  module Messages
-    
-    class Status
-      
-      attr_reader :code, :description, :data
-      
-      def initialize(code,data)
-        @code = code
-        @description = CODES[code]
-        @data = data
-      end
-      
-      def read
-        xml = Builder::XmlMarkup.new
-        xml.SIF_Status { |status|
-          status.SIF_Code(code)
-          status.SIF_Description(description)
-          if data.nil?
-            status.SIF_Data
-          else
-            status.SIF_Data{ |data_node| data_node << data.read }
-          end
-        }
-      end
-      alias :to_str :read
-      
-      def self.method_missing(sym,*args)
-        data = args.first
-        status = nil
-        CODES.each do |key, val|
-          if val.downcase.to_sym == sym
-            status =  Status.new(key,data)
-          end
-        end
-        if status
-          return status
-        else
-          super(sym,*args)
-        end
-      end
-      
-      CODES = {
-        0 => "Success",
-        1 => "Immediate",
-        2 => "Intermediate", 
-        3 => "Final",
-        7 => "Duplicate",
-        8 => "Sleeping", 
-        9 => "No Messages"
-      }
-    end
-    
-  end
-end

data/lib/siffer/messaging.rb

@@ -1,99 +0,0 @@
-module Siffer
-  # The Messaging module takes care of all of the Message handling for
-  # Siffer. It will check messages against content-type constraints as 
-  # well as validate the message XML against constraints outlined in the
-  # SIF Implementation Specification.
-  module Messaging
-
-    include Siffer::Messages
-
-    class BadContentType < Exception #:nodoc:
-    end
-    class MalformedXml < Exception #:nodoc:
-    end
-    class MalformedSIFMessage < Exception #:nodoc:
-    end
-    class XmlNsMismatch < Exception #:nodoc:
-    end
-    class VersionMismatch < Exception #:nodoc:
-    end
-    
-    # Checks the request against the messaging constraints:
-    # * check_content_type
-    # * validate_message
-    # Raises exceptions accordingly.
-    def request_failed_messaging?
-      begin
-        check_content_type
-        validate_message
-      rescue BadContentType
-        # Make a better Not Acceptable response
-         @response = Response.new(Siffer::Protocol::HTTP_STATUS_CODES[406],
-                      406,
-                      {"Content-Type" => MIME_TYPES["htm"]})
-      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
-    
-    # Provides a context for the original message.
-    def using_message_from(request, &block)
-      yield if block_given?
-    end
-    
-    # Reads request content type and validates it's either text/xml
-    # or application/xml;charset=utf-8. If it isn't it will raise a
-    # BadContentType exception.
-    def check_content_type
-      content_type = @request.content_type
-      unless [MIME_TYPES["xml"], 
-              MIME_TYPES["appxml"], 
-              MIME_TYPES["appxmlencoded"]].include? content_type
-        raise BadContentType
-      end
-    end
-    
-    # Validates the Request Body against the constraints of SIF Messaging.
-    # The word "validate" is used loosely as there is no XML validation
-    # currently. 
-    #
-    # Currently validates:
-    # * <tt>well-formed XML</tt> - XML must be well formed.
-    # * <tt>message root</tt> - XML must be a SIF message.
-    # * <tt>version</tt> - Must match SIF version implemented. 
-    # * <tt>xmlns</tt> - Must match xmlns implemented.
-    #
-    # Does not validate:
-    # * valid XML
-    # * different versions of SIF
-    def validate_message
-      begin
-        body = (@request.body.respond_to? :read) ? @request.body.read : @request.body
-        xml = REXML::Document.new(body)
-        # validate Message Root
-        raise MalformedXml if xml.root.nil?
-        # validate Message Root is a SIF_Message
-        raise MalformedSIFMessage if xml.root.name != "SIF_Message"
-        # validate SIF version
-        raise VersionMismatch if xml.root.attributes["version"] != Siffer.sif_version
-        # validate SIF xmlns
-        raise XmlNsMismatch if xml.root.attributes["xmlns"] != Siffer.sif_xmlns
-         # any others?
-      rescue REXML::ParseException
-        raise MalformedXml
-      end
-    end
-  
-    # MIME Types used in Siffer
-    MIME_TYPES = {
-      "appxmlencoded" => "application/xml;charset=utf-8", 
-      "appxml" => "application/xml",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "xml"   => "text/xml"
-    }
-    
-  end
-end

data/lib/siffer/protocol.rb

@@ -1,164 +0,0 @@
-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?
-      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
-    
-    # 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.gsub(/(http|https):\/\//,"")}:#{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 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). 
-    ACCEPTABLE_PATHS = {
-      :root => "/",
-      :ping => "/ping",
-      :status => "/status",
-      :register => "/register"
-    }
-    
-    
-    # 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