click_session 0.0.1

data/lib/click_session/response_serializer.rb

@@ -0,0 +1,34 @@
+module ClickSession
+  class ResponseSerializer
+    def serialize_success(click_session)
+      {
+        id: click_session.id,
+        status: {
+          success: true
+        },
+        data: serializer.serialize(click_session.model)
+      }
+    end
+
+    def serialize_failure(click_session)
+      {
+        id: click_session.id,
+        status: {
+          success: false
+        }
+      }
+    end
+
+    private
+
+    delegate :serializer_class, :notifier_class, to: :clicksession_configuration
+
+    def serializer
+      @serializer ||= serializer_class.new
+    end
+
+    def clicksession_configuration
+      ClickSession.configuration
+    end
+  end
+end

data/lib/click_session/s3_connection.rb

@@ -0,0 +1,34 @@
+module ClickSession
+  class S3Connection
+    attr_reader :bucket_name
+
+    def initialize(
+      key_id = ClickSession.configuration.screenshot[:s3_key_id],
+      access_key = ClickSession.configuration.screenshot[:s3_access_key],
+      bucket_name = ClickSession.configuration.screenshot[:s3_bucket]
+    )
+      @key_id = key_id
+      @access_key = access_key
+      @bucket_name = bucket_name
+    end
+
+    def upload_from_filesystem_to_bucket(file_name, file_path)
+      bucket.objects[file_name].write(
+        Pathname.new(file_path),
+        acl: :public_read
+      )
+    end
+
+    private
+    def bucket
+      @bucket ||= s3.buckets[@bucket_name]
+    end
+
+    def s3
+      @s3 ||= AWS::S3.new(
+        :access_key_id => @key_id,
+        :secret_access_key => @access_key
+      )
+    end
+  end
+end

data/lib/click_session/s3_file_uploader.rb

@@ -0,0 +1,24 @@
+module ClickSession
+  class S3FileUploader
+    def initialize(s3_connection = S3Connection.new)
+      @s3_connection = s3_connection
+    end
+
+    def upload_file(file_name)
+      @s3_connection.upload_from_filesystem_to_bucket(
+          file_name,
+          file_path_for(file_name)
+        )
+      uploaded_file_path_for(file_name)
+    end
+    
+    private
+    def file_path_for(file_name)
+      "#{Rails.root}/tmp/#{file_name}"
+    end
+
+    def uploaded_file_path_for(file_name)
+      "https://s3.amazonaws.com/#{@s3_connection.bucket_name}/#{file_name}"
+    end
+  end
+end

data/lib/click_session/session_state.rb

@@ -0,0 +1,64 @@
+require 'state_machine'
+require 'active_record'
+
+module ClickSession
+  class SessionState < ActiveRecord::Base
+    validates :model_record, presence: true
+
+    state_machine initial: :active do
+      state :active, value: 0
+      state :processed, value: 1
+      state :success_reported, value: 10
+      state :failed_to_process, value: 2
+      state :failure_reported, value: 20
+
+      event :success do
+        transition active: :processed
+      end
+
+      event :failure do
+        transition active: :failed_to_process
+      end
+
+      event :reported_back do
+        transition processed: :success_reported, failed_to_process: :failure_reported
+      end
+    end
+
+    def model=(model)
+      set_model_record_for(model)
+    end
+
+    def model
+      @model ||= model_class.find_by_id(self.model_record)
+    end
+
+    def webhook_attempt_failed
+      self.webhook_attempts += 1
+    end
+
+    private
+
+    delegate :model_class, to: :clicksession_configuration
+
+    def set_model_record_for(model)
+      if model.is_a? Integer
+        self.model_record = model
+      else
+        set_active_record_model_id_for(model)
+      end
+    end
+
+    def set_active_record_model_id_for(model)
+      if model.new_record?
+        model.save!
+      end
+
+      self.model_record = model.id
+    end
+
+    def clicksession_configuration
+      ClickSession.configuration
+    end
+  end
+end

data/lib/click_session/status_reporter.rb

@@ -0,0 +1,81 @@
+module ClickSession
+  class StatusReporter
+
+    MAX_WEBHOOK_ATTEMPTS = 5
+
+    def initialize(webhook)
+      @webhook = webhook
+    end
+
+    delegate :serializer_class, :notifier_class, to: :clicksession_configuration
+
+    def report(click_session)
+      @click_session = click_session
+
+      begin
+        webhook.call(
+          serialized_webhook_message
+        )
+
+        @click_session.reported_back!
+        notifier.session_reported(@click_session)
+      rescue StandardError => e
+        notifier.rescued_error(e)
+        handle_webhook_failure
+      end
+    end
+
+    private
+
+    attr_reader :webhook
+
+    def serialized_webhook_message
+      if @click_session.processed?
+        serialize_success_message
+      else
+        serialize_error_message
+      end
+    end
+
+    def serialize_success_message
+      {
+        id: @click_session.id,
+        status: {
+          success: true
+        },
+        data: serializer.serialize(@click_session.model)
+      }
+    end
+
+    def serialize_error_message
+      {
+        id: @click_session.id,
+        status: {
+          success: false,
+          message: "See error logs"
+        }
+      }
+    end
+
+    def handle_webhook_failure
+      @click_session.webhook_attempt_failed
+      @click_session.save!
+
+      if @click_session.webhook_attempts >= MAX_WEBHOOK_ATTEMPTS
+        notifier.session_failed_to_report(@click_session)
+      end
+    end
+
+    def notifier
+      @notifier ||= notifier_class.new
+    end
+
+    def serializer
+      @serializer ||= serializer_class.new
+    end
+
+    def clicksession_configuration
+      ClickSession.configuration
+    end
+  end
+end

data/lib/click_session/successful_status_reporter.rb

@@ -0,0 +1,15 @@
+module ClickSession
+  class SuccessfulStatusReporter < StatusReporter
+    def initialize(
+      webhook = Webhook.new(ClickSession.configuration.success_callback_url)
+    )
+      super(webhook)
+    end
+
+    def report(click_session)
+      raise ArgumentError unless click_session.processed?
+
+      super(click_session)
+    end
+  end
+end

data/lib/click_session/sync.rb

@@ -0,0 +1,76 @@
+module ClickSession
+
+  # Executes the click session and retuns a serialized response
+  class Sync
+    attr_reader :model
+    attr_accessor :click_session
+
+    def initialize(model)
+      @model = model
+    end
+
+    def run
+      @click_session = SessionState.create!(model: model)
+
+      begin
+        click_session_processor = ClickSessionProcessor.new(
+          click_session,
+          processor,
+          configured_notifier,
+          options
+        )
+
+        click_session_processor.process
+
+        click_session.reported_back!
+        serialize_success_response
+      rescue TooManyRetriesError => e
+        click_session.reported_back!
+        serialize_failure_response
+      end
+    end
+
+    private
+
+    delegate :processor_class, :notifier_class, to: :clicksession_configuration
+
+    def serialize_success_response
+      serializer.serialize_success(click_session)
+    end
+
+    def serialize_failure_response
+      serializer.serialize_failure(click_session)
+    end
+
+    def processor
+      @processor ||= ClickSession::WebRunnerProcessor.new(configured_web_runner)
+    end
+
+    def configured_web_runner
+      @web_runner ||= processor_class.new
+    end
+
+    def configured_notifier
+      @notifier ||= notifier_class.new
+    end
+
+    def options
+      if clicksession_configuration.screenshot_enabled?
+        {
+          screenshot_enabled: true,
+          screenshot_options: clicksession_configuration.screenshot
+        }
+      else
+        {}
+      end
+    end
+
+    def clicksession_configuration
+      ClickSession.configuration
+    end
+
+    def serializer
+      @serializer ||= ClickSession::ResponseSerializer.new
+    end
+  end
+end

data/lib/click_session/version.rb

@@ -0,0 +1,3 @@
+module ClickSession
+  VERSION = "0.0.1"
+end

data/lib/click_session/web_runner.rb

@@ -0,0 +1,60 @@
+require 'capybara'
+require 'capybara/poltergeist'
+
+CAPYBARA_ERRORS = [
+  Capybara::ElementNotFound
+]
+
+module ClickSession
+  class WebRunner
+    include Capybara::DSL
+
+    def initialize
+      Capybara.default_driver = ClickSession.configuration.driver_client
+      Capybara.javascript_driver = ClickSession.configuration.driver_client
+      Capybara.run_server = false
+      page = Capybara::Session.new(ClickSession.configuration.driver_client)
+    end
+
+    def run(model)
+      raise NotImplementedError("You need to override the #steps method by sub classing WebRunner")
+    end
+
+    def reset
+      clear_cookies
+    end
+
+    def save_screenshot(file_name_identity = "")
+      @file_name = build_file_name_for(file_name_identity)
+      page.save_screenshot(screenshot_save_path, full: true)
+
+      S3FileUploader.new.upload_file(@file_name)
+    end
+
+    private
+    def clear_cookies
+      browser = Capybara.current_session.driver.browser
+
+      if browser.respond_to?(:manage) and browser.manage.respond_to?(:delete_all_cookies)
+        browser.manage.delete_all_cookies
+      else
+        page.driver.cookies.keys.each do |cookie|
+          page.driver.remove_cookie(cookie)
+        end
+      end
+    end
+
+    def screenshot_save_path
+      path_for(@file_name)
+    end
+
+    def build_file_name_for(file_name_identity)
+      readable_date = Time.now.strftime("%F_%T")
+      "screenshot-#{file_name_identity}-#{readable_date}.png"
+    end
+
+    def path_for(file_name)
+      "#{Rails.root}/tmp/#{file_name}"
+    end
+  end
+end

data/lib/click_session/web_runner_processor.rb

@@ -0,0 +1,65 @@
+require_relative "./exceptions"
+
+module ClickSession
+  class WebRunnerProcessor
+    def initialize(web_runner)
+      @web_runner = web_runner
+      @retries_made  = 0
+      @making_requests = true
+    end
+
+    delegate :notifier_class, to: :clicksession_configuration
+
+    def process(model)
+      while can_make_requests?
+        begin
+          run_steps_in_browser_with(model)
+        rescue StandardError => e
+          make_note_of_error(e)
+
+          if too_many_retries?
+            raise TooManyRetriesError.new
+          end
+        end
+      end
+
+      model
+    end
+
+    delegate :save_screenshot, to: :web_runner
+
+    private
+    attr_reader :web_runner
+
+    def can_make_requests?
+      @making_requests
+    end
+
+    def stop_making_requests
+      @making_requests = false
+    end
+
+    def run_steps_in_browser_with(model)
+      web_runner.reset
+      web_runner.run(model)
+      stop_making_requests
+    end
+
+    def make_note_of_error(error)
+      @retries_made += 1
+      notifier.rescued_error(error)
+    end
+
+    def too_many_retries?
+      @retries_made > 2
+    end
+
+    def notifier
+      @notifier ||= notifier_class.new
+    end
+
+    def clicksession_configuration
+      ClickSession.configuration
+    end
+  end
+end

data/lib/click_session/webhook.rb

@@ -0,0 +1,24 @@
+require "rest-client"
+
+module ClickSession
+  class Webhook
+    def initialize(url)
+      @url = url
+    end
+
+    def call(message)
+      RestClient.post(
+        url,
+        message.to_json,
+        {
+          content_type: :json,
+          accept: :json,
+        }
+      )
+    end
+
+    private
+
+    attr_reader :url
+  end
+end

data/lib/click_session/webhook_model_serializer.rb

@@ -0,0 +1,7 @@
+module ClickSession
+  class WebhookModelSerializer
+    def serialize(model)
+      model.as_json
+    end
+  end
+end

data/lib/click_session.rb

@@ -0,0 +1,34 @@
+require "click_session/version"
+require "click_session/session_state"
+require "click_session/configuration"
+require "click_session/exceptions"
+require "click_session/notifier"
+
+require "click_session/async"
+require "click_session/sync"
+
+require "click_session/click_session_processor"
+require "click_session/web_runner"
+require "click_session/web_runner_processor"
+
+require "click_session/status_reporter"
+require "click_session/failure_status_reporter"
+require "click_session/successful_status_reporter"
+
+
+require "click_session/response_serializer"
+require "click_session/webhook_model_serializer"
+
+require "click_session/s3_connection"
+require "click_session/s3_file_uploader"
+
+require "click_session/webhook"
+
+
+module StateMachine
+  module Integrations
+    module ActiveModel
+      public :around_validation
+    end
+  end
+end

data/lib/generators/click_session/db/migration/create_session_states.rb

@@ -0,0 +1,13 @@
+class CreateSessionStates < ActiveRecord::Migration
+  def change
+    create_table :session_states  do |t|
+      t.integer "webhook_attempts", default: 0, null: false
+      t.integer "state",            default: 0, null: false
+      t.integer "model_record"
+      t.string  "screenshot_url"
+      t.timestamps null: false
+    end
+
+    add_index :session_states, :model_record, unique: true
+  end
+end

data/lib/generators/click_session/initializers/click_session.rb

@@ -0,0 +1,4 @@
+ClickSession.configure do |config|
+  config.model_class = RenameThisToYourOwnActiveModelClass
+  config.processor_class = ClickSessionRunner
+end

data/lib/generators/click_session/install_generator.rb

@@ -0,0 +1,54 @@
+require 'rails/generators/base'
+require 'rails/generators/active_record'
+
+module ClickSession
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.expand_path('../', __FILE__)
+
+    def create_click_session_migration
+      unless session_states_table_exists?
+        copy_migration 'create_session_states.rb'
+      end
+    end
+
+    def copy_initializer
+      copy_file 'initializers/click_session.rb', 'config/initializers/click_session.rb'
+    end
+
+    private
+
+    def copy_migration(migration_name, config = {})
+      unless migration_exists?(migration_name)
+        migration_template(
+          "db/migration/#{migration_name}",
+          "db/migrate/#{migration_name}",
+          config
+        )
+      end
+    end
+
+    def migration_exists?(name)
+      existing_migrations.include?(name)
+    end
+
+    def existing_migrations
+      @existing_migrations ||= Dir.glob("db/migrate/*.rb").map do |file|
+        migration_name_without_timestamp(file)
+      end
+    end
+
+    def migration_name_without_timestamp(file)
+      file.sub(%r{^.*(db/migrate/)(?:\d+_)?}, '')
+    end
+
+    def session_states_table_exists?
+      ActiveRecord::Base.connection.table_exists?(:session_states)
+    end
+
+    def self.next_migration_number(dir)
+      ActiveRecord::Generators::Base.next_migration_number(dir)
+    end
+  end
+end

data/lib/tasks/click_session.rake

@@ -0,0 +1,52 @@
+require "click_session/configuration"
+
+namespace :click_session do
+  desc "Processes all click_sessions in the 'active' state"
+  task process_active: :environment do
+    def processor_for(session_state)
+      ClickSession::ClickSessionProcessor.new(
+        session_state,
+        ClickSession::WebRunnerProcessor.new(configured_web_runner),
+        ClickSession.configuration.notifier_class.new,
+        processor_options
+      )
+    end
+
+    def configured_web_runner
+      ClickSession.configuration.processor_class.new
+    end
+
+    def processor_options
+      if ClickSession.configuration.screenshot_enabled?
+        {
+          screenshot_enabled: true,
+          screenshot_options: ClickSession.configuration.screenshot
+        }
+      else
+        {}
+      end
+    end
+
+    ClickSession::SessionState.with_state(:active).each do | session_state |
+      processor_for(session_state).process
+    end
+  end
+
+  desc "reports click_sessions in 'processed' state to the webhook"
+  task report_processed: :environment do
+    reporter = ClickSession::SuccessfulStatusReporter.new
+
+    ClickSession::SessionState.with_state(:processed).each do | session_state |
+      reporter.report(session_state)
+    end
+  end
+
+  desc "reports click_sessions in 'failed' state to the webhook"
+  task report_failed: :environment do
+    reporter = ClickSession::FailureStatusReporter.new
+
+    ClickSession::SessionState.with_state(:failed_to_process).each do | session_state |
+      reporter.report(session_state)
+    end
+  end
+end