tent-client 0.0.1 → 0.2.1

data/lib/tent-client/discovery.rb

@@ -1,56 +1,88 @@
+require 'yajl'
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday_middleware/multi_json'
 require 'nokogiri'
+require 'tent-client/link_header'
+require 'uri'
 
 class TentClient
   class Discovery
-    attr_accessor :url, :profile_urls, :primary_profile_url, :profile
+    META_POST_REL = "https://tent.io/rels/meta-post".freeze
 
-    def initialize(client, url)
-      @client, @url = client, url
+    def self.discover(client, entity_uri, options = {})
+      new(client, entity_uri, :skip_serialization => false).discover(options)
     end
 
-    def http
-      @http ||= Faraday.new do |f|
-        f.response :follow_redirects
-        f.adapter *Array(@client.faraday_adapter)
-      end
+    attr_reader :client, :entity_uri
+    attr_accessor :last_response
+    def initialize(client, entity_uri, options = {})
+      @entity_uri = entity_uri
+      @client = client.dup
+      @client.faraday_adapter = :net_http
+      @options = options
     end
 
-    def perform
-      @profile_urls = perform_head_discovery || perform_get_discovery || []
-      @profile_urls.map! { |l| l =~ %r{\A/} ? URI.join(url, l).to_s : l }
-    end
+    def discover(options = {})
+      discover_res, meta_post_urls = perform_head_discovery || perform_get_discovery
+
+      if meta_post_urls.empty?
+        return options[:return_response] ? last_response : nil
+      end
+
+      meta_post_urls.uniq.each do |url|
+        url = URI.join(discover_res.env[:url].to_s, url).to_s
+        begin
+          res = http.get(url) do |request|
+            request.headers['Accept'] = POST_CONTENT_TYPE % "https://tent.io/types/meta/v0#"
+          end
+        rescue Faraday::Error::TimeoutError, Faraday::Error::ConnectionFailed
+          res = Faraday::Response.new({})
+        end
 
-    def get_profile
-      profile_urls.each do |url|
-        res = @client.http.get(url)
-        if res['Content-Type'].split(';').first == MEDIA_TYPE
-          @profile = res.body
-          @primary_profile_url = url
-          break
+        if options[:return_response]
+          return res
+        elsif res.success? && (Hash === res.body)
+          return res.body['post']
         end
       end
-      [@profile, @primary_profile_url.to_s.sub(%r{/profile$}, '')]
+      nil
+    end
+
+    private
+
+    def http
+      @http ||= Faraday.new do |f|
+        f.adapter *Array(client.faraday_adapter)
+        f.response :follow_redirects
+        f.response :multi_json, :content_type => /\bjson\Z/ unless (@options[:skip_serialization] != false) && (client.options[:skip_serialization] || client.options[:skip_response_serialization])
+      end
     end
 
     def perform_head_discovery
-      perform_header_discovery http.head(url)
+      res = http.head(entity_uri)
+      self.last_response = res
+      links = Array(perform_header_discovery(res))
+      [res, links] if links.any?
     end
 
     def perform_get_discovery
-      res = http.get(url)
-      perform_header_discovery(res) || perform_html_discovery(res)
+      res = http.get(entity_uri)
+      self.last_response = res
+      [res, Array(perform_link_discovery(res))]
     end
 
     def perform_header_discovery(res)
       if header = res['Link']
-        links = LinkHeader.parse(header).links.select { |l| l[:rel] == PROFILE_REL }.map { |l| l.uri }
+        links = LinkHeader.parse(header).links.select { |l| l[:rel] == META_POST_REL }.map { |l| l.uri }
         links unless links.empty?
       end
+    rescue LinkHeader::MalformedLinkHeader
     end
 
-    def perform_html_discovery(res)
-      return unless res['Content-Type'] == 'text/html'
-      Nokogiri::HTML(res.body).css(%(link[rel="#{PROFILE_REL}"])).map { |l| l['href'] }
+    def perform_link_discovery(res)
+      return unless res['Content-Type'].to_s.downcase =~ %r{\Atext/html}
+      Nokogiri::HTML(res.body).css(%(link[rel="#{META_POST_REL}"])).map { |l| l['href'] }
     end
   end
 end

data/lib/tent-client/faraday/chunked_adapter.rb

@@ -0,0 +1,100 @@
+require 'net/http'
+require 'faraday/adapter/net_http'
+
+module Faraday
+  class Adapter
+
+    class NetHttpStream < Adapter::NetHttp
+      class BodyStream
+        def initialize(env, &stream_body)
+          @env, @stream_body = env, stream_body
+          @read_body = false
+        end
+
+        def each(&block)
+          return if @read_body
+          @stream_body.call(block)
+          @read_body = true
+        end
+
+        def read
+          return @body if @body
+          @body = ""
+          each do |chunk|
+            @body << chunk
+          end
+          @body
+        end
+      end
+
+      def call(env)
+        env[:request_body] = env[:body]
+
+        request = new_request(env)
+
+        stream_body = proc do |callback|
+          @read_proc = callback
+          request.resume
+        end
+
+        response = request.resume
+        body = BodyStream.new(env, &stream_body)
+
+        save_response(env, response.code.to_i, body) do |response_headers|
+          response.each_header do |key, value|
+            response_headers[key] = value
+          end
+        end
+
+        @app.call(env)
+      rescue *Adapter::NetHttp::NET_HTTP_EXCEPTIONS
+        raise Error::ConnectionFailed, $!
+      rescue Timeout::Error => err
+        raise Faraday::Error::TimeoutError, err
+      end
+
+      private
+
+      def new_request(env)
+        uri = env[:url]
+        Fiber.new do
+          Net::HTTP.start(uri.host, uri.port) do |http|
+            configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
+
+            request = create_request(env)
+
+            req = env[:request]
+            http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
+            http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+
+            http.request(request) do |response|
+              Fiber.yield(response)
+
+              response.read_body do |chunk|
+                @read_proc.call(chunk)
+              end
+            end
+          end
+        end
+      end
+
+      def create_request(env)
+        request = Net::HTTPGenericRequest.new \
+          env[:method].to_s.upcase,    # request method
+          !!env[:body],                # is there request body
+          :head != env[:method],       # is there response body
+          env[:url].request_uri,       # request uri path
+          env[:request_headers]        # request headers
+
+        if env[:request_body].respond_to?(:read)
+          request.body_stream = env[:request_body]
+        else
+          request.body = env[:request_body]
+        end
+        request
+      end
+    end
+
+    Adapter.register_middleware(:net_http_stream => NetHttpStream)
+  end
+end

data/lib/tent-client/faraday/utils.rb

@@ -0,0 +1,10 @@
+module Faraday
+  module Utils
+    class ParamsHash
+      def to_query
+        # Build params normally (e.g. a=1&a=2 rather than a[]=1&a[]=2)
+        Utils.build_query(self)
+      end
+    end
+  end
+end

data/lib/tent-client/link_header.rb

@@ -5,6 +5,8 @@ class TentClient
   class LinkHeader
     attr_accessor :links
 
+    MalformedLinkHeader = Class.new(StandardError)
+
     def self.parse(header)
       new header.split(',').map { |l| Link.parse(l) }
     end
@@ -24,6 +26,9 @@ class TentClient
         s = StringScanner.new(link_text)
         s.scan(/[^<]+/)
         link = s.scan(/<[^\s]+>/)
+
+        raise MalformedLinkHeader.new("Link: #{s.inspect}") unless link
+
         link = link[1..-2]
 
         s.scan(/[^a-z]+/)

data/lib/tent-client/middleware/authentication.rb

@@ -0,0 +1,103 @@
+require 'faraday_middleware'
+require 'hawk'
+
+class TentClient
+  module Middleware
+    class Authentication < Faraday::Middleware
+      AUTHORIZATION_HEADER = 'Authorization'.freeze
+      CONTENT_TYPE_HEADER = 'Content-Type'.freeze
+
+      MAX_RETRIES = 1.freeze
+
+      def initialize(app, credentials, options = {})
+        super(app)
+
+        @credentials = {
+          :id => credentials[:id],
+          :key => credentials[:hawk_key],
+          :algorithm => credentials[:hawk_algorithm]
+        } if credentials
+
+        @ts_skew = options[:ts_skew] || 0
+        @update_ts_skew = options[:update_ts_skew] || lambda {}
+        @ts_skew_retry_enabled = options[:ts_skew_retry_enabled]
+        @retry_count = 0
+      end
+
+      def call(env)
+        set_auth_header(env)
+        res = @app.call(env)
+
+        tsm_header = res.env[:response_headers]['WWW-Authenticate']
+
+        if tsm_header && (tsm_header =~ /tsm/) && (skew = timestamp_skew_from_header(tsm_header)) && @retry_count < MAX_RETRIES
+          @update_ts_skew.call(skew)
+          @ts_skew = skew
+
+          @retry_count += 1
+
+          return call(env) if @ts_skew_retry_enabled
+        end
+
+        res
+      end
+
+      private
+
+      def set_auth_header(env)
+        env[:request_headers][AUTHORIZATION_HEADER] = build_authorization_header(env) if @credentials
+      end
+
+      def timestamp
+        Time.now.to_i + @ts_skew
+      end
+
+      def timestamp_skew_from_header(header)
+        Hawk::Client.calculate_time_offset(header, :credentials => @credentials)
+      end
+
+      def build_authorization_header(env)
+        Hawk::Client.build_authorization_header(
+          :credentials => @credentials,
+          :ts => timestamp,
+          :payload => request_body(env),
+          :content_type => request_content_type(env),
+          :method => request_method(env),
+          :port => request_port(env),
+          :host => request_host(env),
+          :request_uri => request_path(env)
+        )
+      end
+
+      def request_body(env)
+        if env[:body].respond_to?(:read)
+          body = env[:body].read
+          env[:body].rewind if env[:body].respond_to?(:rewind)
+          body
+        else
+          env[:body]
+        end
+      end
+
+      def request_content_type(env)
+        env[:request_headers]['Content-Type'].to_s.split(';').first
+      end
+
+      def request_method(env)
+        env[:method].to_s.upcase
+      end
+
+      def request_port(env)
+        env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
+      end
+
+      def request_host(env)
+        env[:url].host
+      end
+
+      def request_path(env)
+        env[:url].to_s.sub(%r{\A#{env[:url].scheme}://#{env[:url].host}(:#{env[:url].port})?}, '') # maintain query and fragment
+      end
+    end
+  end
+end

data/lib/tent-client/middleware/content_type_header.rb

@@ -0,0 +1,24 @@
+require 'faraday_middleware'
+
+class TentClient
+  module Middleware
+    class ContentTypeHeader < Faraday::Middleware
+      CONTENT_TYPE_HEADER = 'Content-Type'.freeze
+      MEDIA_TYPE = %(application/vnd.tent.post.v0+json; type="%s").freeze
+
+      def call(env)
+        if env[:body] && Hash === env[:body] && !env[:request_headers][CONTENT_TYPE_HEADER]
+          env[:request_headers][CONTENT_TYPE_HEADER] = MEDIA_TYPE % (env[:body]['type'] || env[:body][:type])
+
+          if env[:request]['tent.import']
+            env[:request_headers][CONTENT_TYPE_HEADER] << %(; rel="https://tent.io/rels/import")
+          elsif env[:request]['tent.notification']
+            env[:request_headers][CONTENT_TYPE_HEADER] << %(; rel="https://tent.io/rels/notification")
+          end
+        end
+
+        @app.call env
+      end
+    end
+  end
+end

data/lib/tent-client/middleware/encode_json.rb

@@ -5,10 +5,10 @@ class TentClient
     # FaradayMiddleware::EncodeJson with our media type
     # https://github.com/pengwynn/faraday_middleware/blob/master/lib/faraday_middleware/request/encode_json.rb
     class EncodeJson < Faraday::Middleware
-      CONTENT_TYPE = 'Content-Type'.freeze
+      CONTENT_TYPE_HEADER = 'Content-Type'.freeze
 
       dependency do
-        require 'oj' unless defined?(::Oj)
+        require 'yajl' unless defined?(Yajl)
       end
 
       def call(env)
@@ -19,19 +19,18 @@ class TentClient
       end
 
       def encode(data)
-        ::Oj.dump data
+        Yajl::Encoder.encode(data)
       end
 
       def match_content_type(env)
         if process_request?(env)
-          env[:request_headers][CONTENT_TYPE] ||= MEDIA_TYPE
           yield env[:body] unless env[:body].respond_to?(:to_str)
         end
       end
 
       def process_request?(env)
         type = request_type(env)
-        has_body?(env) and (type.empty? or type == MEDIA_TYPE)
+        has_body?(env) and (type.empty? or type =~ /\bjson\Z/)
       end
 
       def has_body?(env)
@@ -39,7 +38,7 @@ class TentClient
       end
 
       def request_type(env)
-        type = env[:request_headers][CONTENT_TYPE].to_s
+        type = env[:request_headers][CONTENT_TYPE_HEADER].to_s
         type = type.split(';', 2).first if type.index(';')
         type
       end

data/lib/tent-client/multipart-post/parts.rb

@@ -0,0 +1,100 @@
+# Modified version of https://github.com/nicksieger/multipart-post/blob/7d8b74888bf13f702a9590212533f869f0f43f64/lib/parts.rb
+
+require 'parts'
+
+module Parts
+  module Part #:nodoc:
+    def self.new(boundary, name, value, options = {})
+      if value.respond_to?(:content_type)
+        FilePart.new(boundary, name, value, options)
+      else
+        ParamPart.new(boundary, name, value, options)
+      end
+    end
+
+    def length
+      @part.length
+    end
+
+    def to_io
+      @io
+    end
+  end
+
+  class ParamPart
+    include Part
+    def initialize(boundary, name, value, options = {})
+      @part = build_part(boundary, name, value, options)
+      @io = StringIO.new(@part)
+    end
+
+    def length
+     @part.bytesize
+    end
+
+    def build_part(boundary, name, value, options = {})
+      part = []
+      part << "--#{boundary}"
+      part << %(Content-Disposition: form-data; name="#{name.to_s}")
+
+      (options[:headers] || {}).each do |name, value|
+        part << "#{name}: #{value}"
+      end
+
+      part.join("\r\n") << "\r\n\r\n"
+      part << "#{value}\r\n"
+    end
+  end
+
+  # Represents a part to be filled from file IO.
+  class FilePart
+    include Part
+    attr_reader :length
+    def initialize(boundary, name, io, options = {})
+      file_length = io.respond_to?(:length) ?  io.length : File.size(io.local_path)
+
+      options ||= {}
+      options.merge!(
+        :io_opts => io.respond_to?(:opts) ? io.opts : {}
+      )
+
+      @head = build_head(boundary, name, io.original_filename, io.content_type, file_length, options)
+      @foot = "\r\n"
+      @length = @head.length + file_length + @foot.length
+      @io = CompositeReadIO.new(StringIO.new(@head), io, StringIO.new(@foot))
+    end
+
+    def build_head(boundary, name, filename, type, content_len, options = {})
+      io_opts = options[:io_opts]
+      trans_encoding = io_opts["Content-Transfer-Encoding"] || "binary"
+      content_disposition = io_opts["Content-Disposition"] || "form-data"
+
+      options[:headers] ||= {}
+
+      part = []
+      part << "--#{boundary}"
+      part << %(Content-Disposition: #{content_disposition}; name="#{name.to_s}"; filename="#{filename}")
+      part << "Content-Length: #{content_len}"
+      if content_id = io_opts["Content-ID"]
+        part << "Content-ID: #{content_id}"
+      end
+      part << "Content-Type: #{options[:headers].delete('Content-Type') || type}"
+      part << "Content-Transfer-Encoding: #{trans_encoding}"
+
+      options[:headers].each do |name, value|
+        part << "#{name}: #{value}"
+      end
+
+      part.join("\r\n") + "\r\n\r\n"
+    end
+  end
+
+  # Represents the epilogue or closing boundary.
+  class EpiloguePart
+    include Part
+    def initialize(boundary)
+      @part = "--#{boundary}--\r\n\r\n"
+      @io = StringIO.new(@part)
+    end
+  end
+end