F2: Implement Publisher service (#594)

* Pass a client object to the Publisher instead of the credentials

* Define credentials accessors in the feeder config

* Integrate downloader service to the API wrapper

* Refactor Request class

* Accept HTTP client instead of the client params during API wrapper init

* Init downloader with HTTP client instead of the client params

* Refactor request objects initialization

* Use consistent terminology

* Extract post publisher from batch publisher

* Parameterize HTTP client for the downloader

* Reek

* Rubocop

Author: dreikanter

app/services/batch_publisher.rb

@@ -0,0 +1,31 @@
+# Takes a collection of posts, publishes each, updates post status.
+# Does not interrupt on publication error.
+#
+class BatchPublisher
+  include Logging
+
+  attr_reader :posts, :freefeed_client
+
+  def initialize(posts:, freefeed_client:)
+    @posts = posts
+    @freefeed_client = freefeed_client
+  end
+
+  def publish
+    logger.info("publishing #{TextHelpers.pluralize(pending_posts.count, "posts")}")
+
+    posts.each do |post|
+      logger.info("publishing post: #{post.id}")
+      publish_post(post)
+    end
+  end
+
+  private
+
+  def publish_post(post)
+    post.with_lock do
+      next unless post.reload.enqueued?
+      PostPublisher.new(post: post, freefeed_client: freefeed_client).publish
+    end
+  end
+end

app/services/feed_processor.rb

@@ -14,8 +14,20 @@ def initialize(feeds:)
   def perform
     feeds.each do |feed|
       Importer.new(feed).import
-      Publisher.new(posts: feed.posts.pending).publish
+      Publisher.new(posts: feed.posts.pending, freefeed_client: build_freefeed_client).publish
+
       # TBD: Handle errors
     end
   end
+
+  private
+
+  def build_freefeed_client
+    feeder = Rails.configuration.feeder
+
+    Freefeed::Client.new(
+      token: feeder.freefeed_token,
+      base_url: feeder.freefeed_base_url
+    )
+  end
 end

app/services/post_publisher.rb

@@ -0,0 +1,61 @@
+class PostPublisher
+  include Logging
+
+  attr_reader :post, :freefeed_client
+
+  def initialize(post:, freefeed_client:)
+    @post = post
+    @freefeed_client = freefeed_client
+  end
+
+  # TBD :reek:TooManyStatements
+  def publish
+    attachment_ids = create_attachments
+    post_id = create_post(attachment_ids)
+    post.update(freefeed_post_id: post_id)
+    create_comments(post_id)
+    post.success!
+    logger.info("---> new post URL: #{post.permalink}")
+  rescue StandardError
+    post.fail!
+    # TBD: Report error
+  end
+
+  private
+
+  def create_post(attachment_ids)
+    response = freefeed_client.create_post(
+      post: {
+        body: post.text,
+        attachments: attachment_ids
+      },
+      meta: {
+        feeds: [post.feed.name]
+      }
+    )
+
+    response.parse.dig("posts", "id")
+  end
+
+  def create_comments(post_id)
+    post.comments.each do |comment|
+      freefeed_client.create_comment(
+        comment: {
+          body: comment,
+          postId: post_id
+        }
+      )
+    end
+  end
+
+  def create_attachments
+    post.attachments.map { |url| create_attachment(url) }
+  end
+
+  def create_attachment(url)
+    Downloader.call(url) do |io, content_type|
+      response = freefeed_client.create_attachment(io, content_type: content_type)
+      response.parse.fetch("attachments").fetch("id")
+    end
+  end
+end

app/services/publisher.rb

@@ -1,5 +1,7 @@
 shared:
-  freefeed_base_url: "<%= ENV['FREEFEED_BASE_URL'] || 'https://candy.freefeed.net' %>"
+  freefeed_base_url: "<%= ENV.fetch('FREEFEED_BASE_URL') { 'https://candy.freefeed.net' } %>"
+  freefeed_token: "<%= ENV.fetch('FREEFEED_TOKEN') %>"
+
   feeds:
   - name: "xkcd"
     state: "enabled"

config/feeder.yml

@@ -3,7 +3,7 @@ class AuthenticatedRequest < Request
     private
 
     def headers
-      super.merge(authorization: "Bearer #{client.token}")
+      super.merge(authorization: "Bearer #{token}")
     end
   end
 end

lib/freefeed/authenticated_request.rb

@@ -10,9 +10,14 @@ class Client
 
     attr_reader :token, :base_url
 
-    def initialize(token:, base_url: Freefeed::BASE_URL)
+    def initialize(token:, base_url: Freefeed::BASE_URL, http_client: nil)
       @token = token
       @base_url = base_url
+      @http_client = http_client
+    end
+
+    def http_client
+      @http_client ||= HTTP.follow(max_hops: 3).timeout(5)
     end
   end
 end

lib/freefeed/client.rb

@@ -0,0 +1,34 @@
+module Freefeed
+  class Downloader
+    attr_reader :url, :http_client
+
+    def initialize(url:, http_client:)
+      @url = url
+      @http_client = http_client
+    end
+
+    def call
+      # TBD: Honeybadger.context(downloader: {url: url})
+      response = fetch_url
+      return unless response&.status&.success?
+      yield build_io_from(response), response.content_type.mime_type
+    end
+
+    private
+
+    def build_io_from(response)
+      StringIO.new.tap do |io|
+        io.set_encoding(Encoding::BINARY)
+        io.write(response.body.to_s)
+        io.rewind
+      end
+    end
+
+    def fetch_url
+      http_client.get(url)
+    rescue StandardError
+      # TBD: Report download error
+      nil
+    end
+  end
+end

lib/freefeed/downloader.rb

@@ -1,21 +1,16 @@
 module Freefeed
   class Request
-    DEFAULT_OPTIONS = {
-      http_max_hops: 3,
-      http_timeout_seconds: 5
-    }.freeze
+    attr_reader :client, :request_method, :path, :payload
 
-    attr_reader :client, :request_method, :path, :options
-
-    def initialize(client:, request_method:, path:, options: {})
+    def initialize(client:, request_method:, path:, payload: {})
       @client = client
       @request_method = request_method
       @path = path
-      @options = options
+      @payload = payload
     end
 
-    def call
-      response = http.headers(headers).public_send(request_method, uri, **request_params)
+    def perform
+      response = http_client.headers(headers).public_send(request_method, uri, **payload)
       ensure_successful_response(response)
       response
     end
@@ -25,16 +20,12 @@ def call
     def ensure_successful_response(response)
       error = Freefeed::Error.for(response)
       return unless error
-      Honeybadger.context(failed_request_params: request_params)
+      # TBD: Honeybadger.context(failed_request_payload: payload)
       raise(error)
     end
 
     def uri
-      @uri ||= URI.parse(client.base_url + path).to_s
-    end
-
-    def request_params
-      @request_params ||= options.slice(:json, :form, :params, :body)
+      URI.parse(base_url + path).to_s
     end
 
     def headers
@@ -44,12 +35,6 @@ def headers
       }
     end
 
-    def http
-      HTTP.follow(max_hops: option(:http_max_hops)).timeout(option(:http_timeout_seconds))
-    end
-
-    def option(option_name)
-      options.fetch(option_name) { DEFAULT_OPTIONS.fetch(option_name) }
-    end
+    delegate :token, :base_url, :http_client, to: :client, private: true
   end
 end

lib/freefeed/request.rb

@@ -1,21 +1,21 @@
 module Freefeed
   module Utils
-    def authenticated_request(request_method, path, params = {})
+    def authenticated_request(request_method, path, payload = {})
       AuthenticatedRequest.new(
         client: self,
         request_method: request_method,
         path: path,
-        options: params
-      ).call
+        payload: payload
+      ).perform
     end
 
-    def request(request_method, path, params = {})
+    def request(request_method, path, payload = {})
       Request.new(
         client: self,
         request_method: request_method,
         path: path,
-        options: params
-      ).call
+        payload: payload
+      ).perform
     end
   end
 end

lib/freefeed/utils.rb

@@ -4,8 +4,15 @@ module Attachments
       # @param [String, Pathname, IO] source could by a file path
       # or an IO object
       def create_attachment(source, content_type: nil)
-        options = {form: {file: file(source, content_type)}}
-        authenticated_request(:post, "/v1/attachments", options)
+        payload = {form: {file: file(source, content_type)}}
+        authenticated_request(:post, "/v1/attachments", payload)
+      end
+
+      def create_attachment_from(url:)
+        ::Freefeed::Downloader.new(url: url, http_client: http_client).call do |io, content_type|
+          response = create_attachment(io, content_type: content_type)
+          response.parse.fetch("attachments").fetch("id")
+        end
       end
 
       private

lib/freefeed/v1/attachments.rb

@@ -31,8 +31,8 @@ def likes_timeline(username, offset: 0)
       private
 
       def request_timeline(path, offset)
-        params = offset.positive? ? {json: {offset: offset}} : {}
-        authenticated_request(:get, "/v2/timelines/#{path}", params)
+        payload = offset.positive? ? {json: {offset: offset}} : {}
+        authenticated_request(:get, "/v2/timelines/#{path}", payload)
       end
     end
   end

lib/freefeed/v2/timelines.rb

@@ -0,0 +1,44 @@
+require "rails_helper"
+
+RSpec.describe Freefeed::AuthenticatedRequest do
+  let(:client) do
+    Freefeed::Client.new(
+      token: "TEST_TOKEN",
+      base_url: "https://example.com",
+      http_client: HTTP
+    )
+  end
+
+  describe "#perform" do
+    context "when the response is successful" do
+      it "makes a HTTP request without raising an error" do
+        stub_request(:post, "https://example.com/test")
+          .with(
+            body: {payload: "data"}.to_json,
+            headers: {
+              "Authorization" => "Bearer TEST_TOKEN",
+              "Content-Type" => "application/json; charset=utf-8",
+              "User-Agent" => "feeder"
+            }
+          )
+          .to_return(
+            status: 200,
+            headers: {"Content-Type" => "application/json"},
+            body: {"response" => "payload"}.to_json
+          )
+
+        request = described_class.new(
+          client: client,
+          request_method: :post,
+          path: "/test",
+          payload: {json: {"payload" => "data"}}
+        )
+
+        actual = request.perform.parse
+        expected = {"response" => "payload"}
+
+        assert_equal expected, actual
+      end
+    end
+  end
+end

spec/lib/freefeed/authenticated_request_spec.rb

@@ -0,0 +1 @@
+require "rails_helper"