riddl 0.99.105

data/lib/riddl/protocols/http/parser.rb

@@ -0,0 +1,199 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../constants')
+require File.expand_path(File.dirname(__FILE__) + '/../../parameter')
+
+module Riddl
+  module Protocols
+    module HTTP
+      class Parser
+        MULTIPART_CONTENT_TYPES = [
+          #{{{
+          'multipart/form-data',
+          'multipart/related',
+          'multipart/mixed'
+          #}}}
+        ].freeze
+        FORM_CONTENT_TYPES = [
+          #{{{
+          nil,
+          'application/x-www-form-urlencoded'
+          #}}}
+        ].freeze
+
+        def self::unescape(s)
+          #{{{
+          return s if s.nil?  
+          s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+            [$1.delete('%')].pack('H*')
+          }
+          #}}}
+        end
+
+        def parse_content(input,ctype,content_length,content_disposition,content_id,riddl_type)
+          #{{{
+          # fixing for chunked?
+
+          ctype = nil if riddl_type == 'simple'
+          filename = content_disposition[/ filename="?([^\";]*)"?/ni, 1]
+          name = content_disposition[/ name="?([^\";]*)"?/ni, 1] || content_id
+
+          if ctype || filename
+            body = Parameter::Tempfile.new("RiddlMultipart")
+            body.binmode if body.respond_to?(:binmode)
+          else
+            body = ''
+          end
+
+          if content_length == 0 && name == ''
+            body << input.read
+          end
+
+          bufsize = 16384
+          until content_length <= 0
+            c = input.read(bufsize < content_length ? bufsize : content_length)
+            raise EOFError, "bad content body"  if c.nil? || c.empty?
+            body << c
+            content_length -= c.size
+          end
+          body.rewind if body.respond_to?(:binmode)
+
+          add_to_params(name,body,filename,ctype,nil)
+          #}}}
+        end
+        private :parse_content
+
+        def parse_multipart(input,content_type,content_length)
+          #{{{
+          content_type =~ %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
+          boundary = "--#{$1}"
+
+          boundary_size = boundary.size + EOL.size
+          content_length -= boundary_size
+          status = input.read(boundary_size)
+          raise EOFError, "bad content body" unless status == boundary + EOL
+
+          rx = /(?:#{EOL})?#{Regexp.quote boundary}(#{EOL}|--)/n
+
+          buf = ""
+          bufsize = 16384
+          loop do
+            head = nil
+            body = ''
+            filename = ctype = name = nil
+
+            until head && buf =~ rx
+              if !head && i = buf.index(EOL+EOL)
+                head = buf.slice!(0, i+2) # First \r\n
+                buf.slice!(0, 2)          # Second \r\n
+
+                filename = head[/Content-Disposition:.* filename="?([^\";]*)"?/ni, 1]
+                ctype = head[/Content-Type: (.*)#{EOL}/ni, 1]
+                name = head[/Content-Disposition:.*\s+name="?([^\";]*)"?/ni, 1] || head[/Content-ID:\s*([^#{EOL}]*)/ni, 1]
+
+                if ctype || filename
+                  body = Parameter::Tempfile.new("RiddlMultipart")
+                  body.binmode  if body.respond_to?(:binmode)
+                end
+
+                next
+              end
+
+              # Save the read body part.
+              if head && (boundary_size+4 < buf.size)
+                body << buf.slice!(0, buf.size - (boundary_size+4))
+              end
+
+              c = input.read(bufsize < content_length ? bufsize : content_length)
+              raise EOFError, "bad content body"  if c.nil? || c.empty?
+              content_length -= c.size
+              buf << c
+            end
+
+            # Save the rest.
+            if i = buf.index(rx)
+              body << buf.slice!(0, i)
+              buf.slice!(0, boundary_size+2)
+              content_length = -1  if $1 == "--"
+            end
+
+            add_to_params(name,body,filename,ctype,head)
+
+            break if buf.empty? || content_length == -1
+          end
+          #}}}
+        end
+        private :parse_multipart
+
+        def add_to_params(name,body,filename,ctype,head)
+          #{{{
+          if filename == ""
+            # filename is blank which means no file has been selected
+          elsif filename && ctype
+            body.rewind
+
+            # Take the basename of the upload's original filename.
+            # This handles the full Windows paths given by Internet Explorer
+            # (and perhaps other broken user agents) without affecting
+            # those which give the lone filename.
+            filename =~ /^(?:.*[:\\\/])?(.*)/m
+            filename = $1
+
+            @params << Parameter::Complex.new(name, ctype, body, filename, head)
+          elsif !filename && ctype
+            body.rewind
+            
+            # Generic multipart cases, not coming from a form
+            @params << Parameter::Complex.new(name, ctype, body, nil, head)
+          else
+            @params << Parameter::Simple.new(name, body, :body)
+          end
+          #}}}
+        end
+        private :add_to_params
+
+        def parse_nested_query(qs, type)
+          #{{{
+          (qs || '').split(/[#{D}] */n).each do |p|
+            k, v = self.class::unescape(p).split('=', 2)
+            @params << Parameter::Simple.new(k,v,type)
+          end
+          #}}}
+        end
+        private :parse_nested_query
+
+        def initialize(query_string,input,content_type,content_length,content_disposition,content_id,riddl_type)
+          #{{{
+          # rewind because in some cases it is not at start (when multipart without length)
+
+          begin
+            input.rewind if input.respond_to?(:rewind)
+          rescue Errno::ESPIPE
+            # Handles exceptions raised by input streams that cannot be rewound
+            # such as when using plain CGI under Apache
+          end
+
+          media_type = content_type && content_type.split(/\s*[;,]\s*/, 2).first.downcase
+          @params = Riddl::Parameter::Array.new
+          parse_nested_query(query_string,:query)
+          if MULTIPART_CONTENT_TYPES.include?(media_type)
+            parse_multipart(input,content_type,content_length.to_i)
+          elsif FORM_CONTENT_TYPES.include?(media_type)
+            # sub is a fix for Safari Ajax postings that always append \0
+            parse_nested_query(input.read.sub(/\0\z/, ''),:body)
+          else 
+            parse_content(input,content_type,content_length.to_i,content_disposition||'',content_id||'',riddl_type||'')
+          end
+
+          begin
+            input.rewind if input.respond_to?(:rewind)
+          rescue Errno::ESPIPE
+            # Handles exceptions raised by input streams that cannot be rewound
+            # such as when using plain CGI under Apache
+          end
+          #}}}
+        end
+
+        attr_reader :params
+      end
+    end
+  end
+end  

data/lib/riddl/protocols/websocket.rb

@@ -0,0 +1,103 @@
+gem 'em-websocket', '>= 0.4.0'
+require 'em-websocket'
+require 'thin'
+
+module Thin #{{{
+  class Connection
+    attr_accessor :websocket
+    def websocket?
+      !self.websocket.nil?
+    end
+
+    def pre_process_with_websocket
+      @request.env['thin.connection'] = self
+      pre_process_without_websocket
+    end
+    alias :pre_process_without_websocket :pre_process
+    alias :pre_process :pre_process_with_websocket
+
+    def receive_data_with_websocket(data)
+      if self.websocket?
+        self.websocket.receive_data(data)
+      else
+        receive_data_without_websocket(data)
+      end
+    end
+    alias :receive_data_without_websocket :receive_data
+    alias :receive_data :receive_data_with_websocket
+
+    def unbind_with_websocket
+      if self.websocket?
+        self.websocket.unbind
+      else
+        unbind_without_websocket
+      end
+    end
+    alias :unbind_without_websocket :unbind
+    alias :unbind :unbind_with_websocket
+  end
+end   #}}}
+
+class WebSocketParserData
+  attr_accessor :headers, :request_path, :query_string, :http_method, :body, :request_url
+  def match(what)
+    @body =~ what 
+  end
+  def upgrade?
+    true
+  end
+end
+
+module EventMachine
+  module WebSocket
+    class Handshake
+      def receive_data(data)
+        @parser = data
+        @headers = data.headers
+        process(@headers, data.body)
+      end
+    end
+  end  
+end  
+
+module Riddl
+  class WebSocket < ::EventMachine::WebSocket::Connection
+    class Error < RuntimeError; end
+
+    def self.new(*args)
+      instance = allocate
+      instance.__send__(:initialize, *args)
+      instance
+    end
+
+    def send_data(*args)
+      EM.next_tick do
+        @socket.send_data(*args)
+      end  
+    end
+
+    def close_connection(*args)
+      EM.next_tick do
+        @socket.close_connection(*args)
+      end  
+    end
+
+    def trigger_on_message(msg);    @app.onmessage(msg);                        end
+    def trigger_on_open(handshake); @closed = false; @app.onopen;               end
+    def trigger_on_close;           @closed = true;  @app.onclose;              end
+    def trigger_on_error(error);    @closed = true;  @app.onerror(error); true; end
+
+    def initialize(app, socket)
+      @app = app
+      @socket = socket
+      @ssl = socket.backend.respond_to?(:ssl?) && socket.backend.ssl?
+      @closed = true
+      socket.websocket = self
+      socket.comm_inactivity_timeout = 0
+    end
+
+    def closed?
+      @closed
+    end
+  end
+end

data/lib/riddl/protocols/xmpp/generator.rb

@@ -0,0 +1,176 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../constants')
+require 'blather/client/client'
+require 'securerandom'
+
+module Riddl
+  module Protocols
+    module XMPP
+      XR_NS = 'http://www.fp7-adventure.eu/ns/xmpp-rest'.freeze
+
+      class Stanza < Blather::Stanza
+        def self.new
+          node = super :message
+          node.type = :normal
+          node.id = SecureRandom.uuid
+          node
+        end
+      end
+
+      class Error
+        MAPPING = {
+          302 => ['redirect'                , 'modify' , '302 Redirect'              ],
+          400 => ['bad-request'             , 'modify' , '400 Bad Request'           ],
+          401 => ['not-authorized'          , 'auth'   , '401 Not Authorized '       ],
+          402 => ['payment-required'        , 'auth'   , '402 Payment Required'      ],
+          403 => ['forbidden'               , 'auth'   , '403 Forbidden'             ],
+          404 => ['item-not-found'          , 'cancel' , '404 Not Found'             ],
+          405 => ['not-allowed'             , 'cancel' , '405 Not Allowed'           ],
+          406 => ['not-acceptable'          , 'modify' , '406 Not Acceptable'        ],
+          407 => ['registration-required'   , 'auth'   , '407 Registration Required' ],
+          408 => ['remote-server-timeout'   , 'wait'   , '408 Request Timeout'       ],
+          409 => ['conflict'                , 'cancel' , '409 Conflict'              ],
+          500 => ['internal-server-error'   , 'wait'   , '500 Internal Server Error' ],
+          501 => ['feature-not-implemented' , 'cancel' , '501 Not Implemented'       ],
+          502 => ['service-unavailable'     , 'wait'   , '502 Remote Server Error'   ],
+          503 => ['service-unavailable'     , 'cancel' , '503 Service Unavailable'   ],
+          504 => ['remote-server-timeout'   , 'wait'   , '504 Remote Server Timeout' ],
+          510 => ['service-unavailable'     , 'cancel' , '510 Disconnected'          ]
+        }.freeze
+        UNDEFINED = [
+          'undefined-condition', 'modify'
+        ].freeze
+
+        def initialize(err)
+          m = Stanza.new
+          @stanza = if MAPPING[err]
+            Blather::StanzaError.new(m,*MAPPING[err]).to_node
+          else
+            Blather::StanzaError.new(m,*UNDEFINED,'#{err} see http://www.iana.org/assignments/http-status-codes/http-status-codes.xml').to_node
+          end
+        end
+
+        def generate
+          @stanza
+        end
+      end
+
+      class Generator
+        def initialize(what,params,headers)
+          @params = params
+          @stanza = Stanza.new
+          @node = XML::Smart::Dom::Element.new(@stanza)
+          if what.is_a?(Fixnum)
+            @node.add('ok').namespaces.add(nil,XR_NS)
+          else
+            @node.add('operation',what).namespaces.add(nil,XR_NS)
+          end
+          headers.each do |k,v|
+            @node.add('header',v,:name => k).namespaces.add(nil,XR_NS)
+          end
+        end
+
+        # Performs URI escaping so that you can construct proper
+        # query strings faster.  Use this rather than the cgi.rb
+        # version since it's faster. (%20 instead of + for improved standards conformance).
+        def self.escape(s)
+          s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) {
+            '%'+$1.unpack('H2'*$1.size).join('%').upcase
+          }
+        end
+
+        def generate(mode=:output)
+          if @params.is_a?(Array) && @params.length == 1
+            body(@params[0],mode)
+          elsif @params.class == Riddl::Parameter::Simple || @params.class == Riddl::Parameter::Complex
+            body(@params,mode)
+          elsif @params.is_a?(Array) && @params.length > 1
+            multipart(mode)
+          else
+            @stanza
+          end  
+        end
+
+        def body(r,mode)
+          case r
+            when Riddl::Parameter::Simple
+              if mode == :output
+                n = @node.add('part',r.value)
+                n.namespaces.add(nil,XR_NS)
+                n.attributes['content-type'] = 'text/plain'
+                n.attributes['content-id'] = r.name
+                n.attributes['RIDDL-TYPE'] = 'simple'
+              end
+              if mode == :input
+                n = @node.add('part')
+                n.namespaces.add(nil,XR_NS)
+                n.attributes['content-type'] = 'application/x-www-form-urlencoded'
+                n.text = self.class::escape(r.name) + '=' + self.class::escape(r.value)
+              end
+            when Riddl::Parameter::Complex
+              n = @node.add('part')
+              n.namespaces.add(nil,XR_NS)
+              n.text = (r.value.respond_to?(:read) ? r.value.read : r.value)
+              n.attributes['content-type'] = r.mimetype
+              n.attributes['RIDDL-TYPE'] = 'complex'
+              if r.filename.nil?
+                n.attributes['content-id'] = r.name
+              else
+                n.attributes['content-disposition'] = "riddl-data; name=\"#{r.name}\"; filename=\"#{r.filename}\""
+              end  
+          end
+          @stanza
+        end
+        private :body
+
+        def multipart(mode)
+          scount = ccount = 0
+          @params.each do |r|
+            case r
+              when Riddl::Parameter::Simple
+                scount += 1
+              when Riddl::Parameter::Complex
+                ccount += 1
+            end   
+          end
+          if scount > 0 && ccount == 0
+            n = @node.add('part')
+            n.namespaces.add(nil,XR_NS)
+            n.attributes['content-type'] = 'application/x-www-form-urlencoded'
+            res = []
+            @params.each do |r|
+              case r
+                when Riddl::Parameter::Simple
+                  res << self.class::escape(r.name) + '=' + self.class::escape(r.value)
+              end   
+            end
+            n.text = res.join('&')
+          else
+            if scount + ccount > 0
+              @params.each do |r|
+                case r
+                  when Riddl::Parameter::Simple
+                    n = @node.add('part')
+                    n.namespaces.add(nil,XR_NS)
+                    n.attributes['RIDDL-TYPE'] = 'simple'
+                    n.attributes['content-disposition'] = "#{mode == :input ? 'form-data' : 'riddl-data'}; name=\"#{r.name}\""
+                    n.text = r.value
+                  when Riddl::Parameter::Complex
+                    n = @node.add('part')
+                    n.namespaces.add(nil,XR_NS)
+                    n.attributes['RIDDL-TYPE'] = 'complex'
+                    n.attributes['content-disposition'] = "#{mode == :input ? 'form-data' : 'riddl-data'}; name=\"#{r.name}\"#{r.filename.nil? ? '' : "; filename=\"#{r.filename}\""}"
+                    n.attributes['content-transfer-encoding'] = 'binary'
+                    n.attributes['content-type'] = r.mimetype
+                    n.text = (r.value.respond_to?(:read) ? r.value.read : r.value)
+                end   
+              end
+            end
+          end
+          @stanza
+        end
+        private :multipart
+      
+      end
+    end
+  end
+end