startback-jobs 0.13.0 → 0.14.0

data/lib/startback/web/cors_headers.rb

@@ -0,0 +1,80 @@
+module Startback
+  module Web
+    #
+    # Sets Cross-Origin Response Headers on requests specifying an Origin
+    # HTTP header, according configuration passed at construction and/or
+    # environment variables.
+    #
+    # Example:
+    #
+    #     # Default configuration, using environment variables when set
+    #     use CorsHeaders
+    #
+    #     # Force a bouncing of the origin, using the Origin request header
+    #     # as Access-Control-Allow-Origin response header
+    #     use CorsHeaders, bounce: true
+    #
+    #     # Overrides a specific header
+    #     use CorsHeaders, headers: { 'Access-Control-Allow-Methods' => 'POST' }
+    #
+    class CorsHeaders
+
+      ALLOW_ORIGIN = ENV['STARTBACK_CORS_ALLOW_ORIGIN'] || '*'
+
+      ALLOW_METHODS = ENV['STARTBACK_CORS_ALLOW_METHODS'] || 'OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE'
+
+      ALLOW_CREDENTIALS = ENV['STARTBACK_CORS_ALLOW_CREDENTIALS'] || 'true'
+
+      MAX_AGE = ENV['STARTBACK_CORS_MAX_AGE'] || '1728000'
+
+      ALLOW_HEADERS = ENV['STARTBACK_CORS_ALLOW_HEADERS'] || 'Authorization, Content-Type, Origin, Accept, If-Modified-Since, If-Match, If-None-Match'
+
+      EXPOSE_HEADERS = ENV['STARTBACK_CORS_EXPOSE_HEADERS'] || 'Location, ETag, Last-Modified, Content-Type'
+
+      DEFAULT_CORS_HEADERS = {
+        'Access-Control-Allow-Origin' => ALLOW_ORIGIN,
+        'Access-Control-Allow-Methods' => ALLOW_METHODS,
+        'Access-Control-Allow-Credentials' => ALLOW_CREDENTIALS,
+        'Access-Control-Max-Age' => MAX_AGE,
+        'Access-Control-Allow-Headers' => ALLOW_HEADERS,
+        'Access-Control-Expose-Headers' => EXPOSE_HEADERS
+      }
+
+      DEFAULT_OPTIONS = {
+        :headers => DEFAULT_CORS_HEADERS
+      }
+
+      def initialize(app, options = {})
+        @app = app
+        @options = Startback::Support.deep_merge(DEFAULT_OPTIONS, options)
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        if origin = env['HTTP_ORIGIN']
+          headers = cors_headers(origin).merge(headers)
+        end
+        if env['REQUEST_METHOD'] == 'OPTIONS'
+          headers['Content-Length'] = '0'
+          status, headers, body = [204, headers, []]
+        end
+        [status, headers, body]
+      end
+
+    private
+
+      def cors_headers(origin)
+        headers = @options[:headers].dup
+        if bounce?
+          headers['Access-Control-Allow-Origin'] = origin
+        end
+        headers
+      end
+
+      def bounce?
+        @options[:bounce]
+      end
+
+    end # class AllowCors
+  end # class CorsHeaders
+end # module Samback

data/lib/startback/web/health_check.rb

@@ -0,0 +1,49 @@
+module Startback
+  module Web
+    #
+    # Can be used to easily implement a HealthCheck web service inside a Startback
+    # application.
+    #
+    # Examples:
+    #
+    #     # Returns a 204 with no body
+    #     run Startback::Web::HealthCheck.new
+    #
+    #     # Returns a 204 with no body
+    #     run Startback::Web::HealthCheck.new { nil }
+    #
+    #     # Returns a 200 with Ok in plain text
+    #     run Startback::Web::HealthCheck.new { "Ok" }
+    #
+    #     # Re-raises the exception
+    #     run Startback::Web::HealthCheck.new { raise "Something bad" }
+    #
+    # Please note that this rack app is not 100% Rack compliant, since it raises
+    # any error that the block itself raises. This class aims at being backed up
+    # by a Shield and/or CatchAll middleware.
+    #
+    # This class is not aimed at being subclassed.
+    #
+    class HealthCheck
+
+      def initialize(&bl)
+        @checker = bl
+      end
+
+      def call(env)
+        if debug_msg = check!(env)
+          [ 200, { "Content-Type" => "text/plain" }, Array(debug_msg) ]
+        else
+          [ 204, {}, [] ]
+        end
+      end
+
+    protected
+
+      def check!(env)
+        @checker.call if @checker
+      end
+
+    end # class HealthCheck
+  end # module Web
+end # module Startback

data/lib/startback/web/magic_assets/ng_html_transformer.rb

@@ -0,0 +1,80 @@
+module Startback
+  module Web
+    class MagicAssets
+      #
+      # Plugin for MagicAssets that compiles .html angular templates in the
+      # assets structure to javascript files filling angular's template cache.
+      #
+      # Heavily inspired, yet over-simplified version, of angular-rails-templates
+      # See https://github.com/pitr/angular-rails-templates, licensed under MIT
+      #
+      # Example:
+      #
+      #   use Startback::Web::MagicAssets, {
+      #     plugins: [Startback::Web::MagicAssets::NgHtmlTransfomer.new]
+      #   }
+      #
+      class NgHtmlTransformer
+
+        DEFAULT_OPTIONS = {
+          :path       => '/assets',
+          :ng_module  => 'templates',
+          :mime_type  => 'text/ng-html',
+          :extensions => [".html"]
+        }
+
+        def initialize(options = {})
+          @options = DEFAULT_OPTIONS.merge(options)
+        end
+        attr_reader :options
+
+        def install(sprockets)
+          sprockets.register_mime_type options[:mime_type], extensions: options[:extensions]
+          sprockets.register_transformer options[:mime_type], 'application/javascript', self
+        end
+
+TPL = <<-EOF
+angular.module("<%= ng_module %>").run(["$templateCache", function($templateCache) {
+  $templateCache.put("<%= angular_template_name %>", <%= html %>)
+}]);
+EOF
+
+        # inspired by Rails' action_view/helpers/javascript_helper.rb
+        JS_ESCAPE_MAP = {
+          '\\'    => '\\\\',
+          "\r\n"  => '\n',
+          "\n"    => '\n',
+          "\r"    => '\n',
+          '"'     => '\\"',
+          "'"     => "\\'"
+        }
+
+        # We want to deliver the shortist valid javascript escaped string
+        # Count the number of " vs '
+        # If more ', escape "
+        # If more ", escape '
+        # If equal, prefer to escape "
+
+        def escape_javascript(raw)
+          if raw
+            quote = raw.count(%{'}) >= raw.count(%{"}) ? %{"} : %{'}
+            escaped = raw.gsub(/(\\|\r\n|[\n\r#{quote}])/u) {|match| JS_ESCAPE_MAP[match] }
+            "#{quote}#{escaped}#{quote}"
+          else
+            '""'
+          end
+        end
+
+        def call(input)
+          file_path = input[:filename]
+          angular_template_name = "#{options[:path]}/#{input[:name]}.html"
+          source_file = file_path
+          ng_module = options[:ng_module]
+          html = escape_javascript(input[:data].chomp)
+          ERB.new(TPL).result(binding)
+        end
+
+      end # class NgHtmlTransformer
+    end # class MagicAssets
+  end # module Web
+end # module Startback

data/lib/startback/web/magic_assets/rake_tasks.rb

@@ -0,0 +1,64 @@
+module Startback
+  module Web
+    class MagicAssets
+      class RakeTasks
+
+        DEFAULT_OPTIONS = {
+          :namespace => :assets
+        }
+
+        def initialize(rake, options)
+          @rake = rake
+          @options = DEFAULT_OPTIONS.merge(options)
+          install
+        end
+        attr_reader :rake, :options
+
+      private
+
+        def install
+          require 'securerandom'
+
+          ns = options[:namespace]
+          target_folder = options[:target]
+          assets = options[:assets]
+          assets = MagicAssets.new(assets) if assets.is_a?(Hash)
+          version = SecureRandom.urlsafe_base64
+
+          rake.instance_exec do
+            namespace(ns) do
+
+              desc 'Cleans generated assets'
+              task :clean do
+                FileUtils.rm_rf target_folder
+              end
+
+              task :prepare do
+                FileUtils.mkdir_p target_folder
+                (target_folder/"VERSION").write(version)
+              end
+
+              desc 'compile javascript assets'
+              task :compile_js do
+                assets['vendor.js'].write_to(target_folder/"vendor-#{version}.min.js")
+                assets['app.js'].write_to(target_folder/"app-#{version}.min.js")
+                puts "successfully compiled js assets"
+              end
+
+              desc 'compile css assets'
+              task :compile_css do
+                assets['vendor.css'].write_to(target_folder/"vendor-#{version}.min.css")
+                assets['app.css'].write_to(target_folder/"app-#{version}.min.css")
+                puts "successfully compiled css assets"
+              end
+
+              desc 'compile assets'
+              task :compile => [:clean, :prepare, :compile_js, :compile_css]
+            end
+          end
+        end
+
+      end
+    end # class MagicAssets
+  end # module Web
+end # module Startback

data/lib/startback/web/magic_assets.rb

@@ -0,0 +1,98 @@
+require 'sprockets'
+module Startback
+  module Web
+    #
+    # Rack application & middleware that can be used to simplify javascript
+    # and css assets management, using Sprockets.
+    #
+    # Example:
+    #
+    #     # Used as rack app, typically under a path
+    #     Rack::Builder.new do
+    #       map '/assets' do
+    #         run Startback::Web::MagicAssets.new({
+    #           folder: "/path/to/assets/src"
+    #         })
+    #       end
+    #       run MyApp
+    #     end
+    #
+    #     # Used as a rack middleware, e.g. in a Sinatra application
+    #     use Startback::Web::MagicAssets, {
+    #       folder: "/path/to/assets/src",
+    #       path: "/assets"
+    #     }
+    #
+    # Sprocket configuration can be done through the `:sprocket` option:
+    #
+    #     use Startback::Web::MagicAssets, {
+    #       sprockets: {
+    #         :css_compressor => :scss
+    #       }
+    #     }
+    #
+    class MagicAssets
+
+      DEFAULT_OPTIONS = {
+        sprockets: {},
+        plugins: {}
+      }
+
+      def initialize(app, options = {})
+        app, options = nil, app if app.is_a?(Hash)
+        @app = app
+        @options = DEFAULT_OPTIONS.merge(options)
+        @sprockets = build_sprockets
+      end
+      attr_reader :sprockets
+
+      def call(env)
+        if new_env = is_match?(env)
+          @sprockets.call(new_env)
+        else
+          @app.call(env)
+        end
+      end
+
+      def [](*args, &bl)
+        @sprockets.[](*args, &bl)
+      end
+
+    private
+
+      def path
+        @options[:path]
+      end
+
+      def is_match?(env)
+        if @app.nil?
+          # Not used as a middleware, use this env and match
+          env
+        elsif env['PATH_INFO'].start_with?(path)
+          # Used as a middleware, and PATH_INFO starts with the
+          # assets path => strip it for sprockets
+          env.merge("PATH_INFO" => env["PATH_INFO"].sub(path, ""))
+        else
+          # No match, let @app execute with the untouched environment
+          nil
+        end
+      end
+
+      def build_sprockets
+        Sprockets::Environment.new.tap{|s|
+          Array(@options[:folder]).each do |folder|
+            s.append_path(folder)
+          end
+          @options[:sprockets].each_pair do |k,v|
+            s.public_send(:"#{k}=", v)
+          end
+          @options[:plugins].each do |p|
+            p.install(s)
+          end
+        }
+      end
+
+    end # class MagicAssets
+  end # module Web
+end # module Startback
+require_relative 'magic_assets/rake_tasks'

data/lib/startback/web/middleware.rb

@@ -0,0 +1,13 @@
+module Startback
+  module Web
+    module Middleware
+
+    protected
+
+      def context(env = @env)
+        ::Startback::Context::Middleware.context(env) || Errors.server_error!("Unable to find context!!")
+      end
+
+    end # module Middleware
+  end # module Web
+end # module Startback

data/lib/startback/web/prometheus.rb

@@ -0,0 +1,16 @@
+require 'prometheus/middleware/exporter'
+module Startback
+  module Web
+    #
+    # Can be used to expose the prometheus metrics inside a Startback
+    # application.
+    #
+    # Example:
+    #
+    #     use Startback::Web::Prometheus
+    #
+    class Prometheus < Prometheus::Middleware::Exporter
+
+    end # class Prometheus
+  end # module Web
+end # module Startback

data/lib/startback/web/shield.rb

@@ -0,0 +1,58 @@
+module Startback
+  module Web
+    #
+    # This Rack middleware catches all known exceptions raised by sublayers
+    # in the Rack chain. Those exceptions are converted to proper HTTP error
+    # codes and friendly error messages encoded in json.
+    #
+    # Please check the Errors module about status codes used for each Startback
+    # error.
+    #
+    # This class aims at being used as top level of a Rack chain.
+    #
+    # Examples:
+    #
+    #     Rack::Builder.new do
+    #       use Startback::Web::Shield
+    #     end
+    #
+    class Shield < Rack::Robustness
+      include Errors
+
+      self.no_catch_all
+      self.content_type 'application/json'
+
+      # Decoding errors from json and csv are considered user's fault
+      self.on(Finitio::TypeError){ 400 }
+      self.on(::NotImplementedError){ 501 }
+
+      # Various other codes for the framework specific error classes
+      self.on(Startback::Errors::Error) {|ex|
+        ex.class.status
+      }
+
+      # A bit of logic to choose the best error message for the user
+      # according to the error class
+      self.body{|ex|
+        body_for(ex).to_json
+      }
+
+      def body_for(ex)
+        ex = ex.root_cause if ex.is_a?(Finitio::TypeError)
+        body = { code: ex.class.name, description: ex.message }
+        return body unless ex.is_a?(Startback::Errors::Error)
+        return body unless ex.has_causes?
+
+        body[:causes] = ex.causes
+          .filter{|cause|
+            cause.is_a?(Startback::Errors::Error)
+          }
+          .map{|cause|
+            body_for(cause)
+          }
+        body
+      end
+
+    end # class Shield
+  end # module Web
+end # module Startback

data/lib/startback.rb

@@ -0,0 +1,43 @@
+require 'sinatra'
+require 'rack/robustness'
+require 'finitio'
+require 'logger'
+require 'path'
+require 'ostruct'
+require 'benchmark'
+
+# Provides a reusable backend framework for backend components written
+# in ruby.
+#
+# The framework installs conventions regarding:
+#
+# - The exposition of web service APIs (Framework::Api, on top of Sinatra)
+# - Operations (Framework::Operation)
+# - Error handling (Framework::Errors) and their handling in web APIs
+#   (based on Rack::Robustness)
+# - General code support (Framework::Support modules & classes).
+#
+# Please refer to the documentation of those main abstractions for details.
+#
+module Startback
+
+  # Simply checks that a path exists of raise an error
+  def self._!(path)
+    Path(path).tap do |p|
+      raise "Missing #{p.basename}." unless p.exists?
+    end
+  end
+
+  require_relative 'startback/version'
+  require_relative 'startback/ext'
+  require_relative 'startback/errors'
+  require_relative 'startback/support'
+  require_relative 'startback/model'
+  require_relative 'startback/context'
+  require_relative 'startback/operation'
+  require_relative 'startback/services'
+
+  # Logger instance to use for the application
+  LOGGER = ::Startback::Support::Logger.new
+
+end # module Startback

data/spec/spec_helper.rb

@@ -1,42 +1,49 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'startback'
-require 'startback/jobs'
+require 'startback/event'
+require 'startback/support/fake_logger'
 require 'rack/test'
-require 'bmg'
+require 'ostruct'
 
 module SpecHelpers
 end
 
 RSpec.configure do |c|
   c.include SpecHelpers
+end
+
+class SubContext < Startback::Context
+
+  attr_accessor :foo
+
+  h_factory do |c,h|
+    c.foo = h["foo"]
+  end
+
+  h_dump do |h|
+    h.merge!("foo" => foo)
+  end
 
-  def a_job_data(override = {})
-    {
-      id: 'abcdef',
-      isReady: false,
-      opClass: 'CowSay',
-      opInput: { 'message' => 'Hello !!' },
-      opContext: {},
-      opResult: nil,
-      strategy: 'NotReady',
-      strategyOptions: {},
-      expiresAt: nil,
-      refreshFreq: nil,
-      refreshedAt: nil,
-      consumeMax: nil,
-      consumeCount: 0,
-      createdAt: DateTime.now,
-      createdBy: 'blambeau',
-    }.merge(override)
+  world(:partner) do
+    Object.new
   end
+
 end
 
-class CowSay < Startback::Operation
-  def initialize(input)
-    @input = Startback::Model.new(input)
+class SubContext
+
+  attr_accessor :bar
+
+  h_factory do |c,h|
+    c.bar = h["bar"]
   end
 
-  def call
-    input.message
+  h_dump do |h|
+    h.merge!("bar" => bar)
+  end
+
+end
+
+class User
+  class Changed < Startback::Event
   end
 end

data/spec/unit/audit/test_prometheus.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'startback/audit'
+module Startback
+  module Audit
+    describe Prometheus do
+
+      EXPORTER = Prometheus.new({
+        prefix: "hello",
+        labels: {
+          app_version: "1.0"
+        }
+      })
+
+      class Runner
+        include Startback::Support::OperationRunner
+
+        class IdealOp < Startback::Operation
+          def call
+            42
+          end
+        end
+
+        class ExceptionalOp < Startback::Operation
+          def call
+            raise "Oops"
+          end
+        end
+
+        around_run(EXPORTER)
+        def test
+          run IdealOp.new
+        end
+        def test_exp
+          run ExceptionalOp.new
+        end
+      end
+
+      describe 'The ideal case' do
+        before do
+          expect(EXPORTER.calls).to receive(:observe).with(
+            kind_of(Numeric),
+            hash_including(labels: {
+              operation: "Startback::Audit::Runner::IdealOp",
+              startback_version: Startback::VERSION,
+              app_version: "1.0"
+            }))
+          expect(EXPORTER.errors).not_to receive(:increment)
+        end
+        it 'runs the operation' do
+          expect(Runner.new.test).to eql(42)
+        end
+      end
+
+      describe 'The exceptional case' do
+        before do
+          expect(EXPORTER.errors).to receive(:increment).with(
+            hash_including(labels: {
+              operation: "Startback::Audit::Runner::ExceptionalOp",
+              startback_version: Startback::VERSION,
+              app_version: "1.0"
+            })
+          )
+          expect(EXPORTER.calls).not_to receive(:observe)
+        end
+        it 'let errors bubble up' do
+          expect { Runner.new.test_exp }.to raise_error(/Oops/)
+        end
+      end
+
+    end
+  end
+end