pliny 0.0.1.pre

data/lib/pliny/middleware/cors.rb

@@ -0,0 +1,46 @@
+module Pliny::Middleware
+  class CORS
+
+    ALLOW_METHODS  =
+      %w( GET POST PUT PATCH DELETE OPTIONS ).freeze
+    ALLOW_HEADERS  =
+      %w( * Content-Type Accept AUTHORIZATION Cache-Control ).freeze
+    EXPOSE_HEADERS =
+      %w( Cache-Control Content-Language Content-Type Expires Last-Modified Pragma ).freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # preflight request: render a stub 200 with the CORS headers
+      if cors_request?(env) && env["REQUEST_METHOD"] == "OPTIONS"
+        [200, cors_headers(env), [""]]
+      else
+        status, headers, response = @app.call(env)
+
+        # regualar CORS request: append CORS headers to response
+        if cors_request?(env)
+          headers.merge!(cors_headers(env))
+        end
+
+        [status, headers, response]
+      end
+    end
+
+    def cors_request?(env)
+      env.has_key?("HTTP_ORIGIN")
+    end
+
+    def cors_headers(env)
+      {
+        'Access-Control-Allow-Origin'      => env["HTTP_ORIGIN"],
+        'Access-Control-Allow-Methods'     => ALLOW_METHODS.join(', '),
+        'Access-Control-Allow-Headers'     => ALLOW_HEADERS.join(', '),
+        'Access-Control-Allow-Credentials' => "true",
+        'Access-Control-Max-Age'           => "1728000",
+        'Access-Control-Expose-Headers'    => EXPOSE_HEADERS.join(', ')
+      }
+    end
+  end
+end

data/lib/pliny/middleware/request_id.rb

@@ -0,0 +1,42 @@
+# please add changes here to core's Instruments as well
+
+module Pliny::Middleware
+  class RequestID
+    UUID_PATTERN =
+      /\A[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\Z/
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request_ids = [SecureRandom.uuid] + extract_request_ids(env)
+
+      # make ID of the request accessible to consumers down the stack
+      env["REQUEST_ID"] = request_ids[0]
+
+      # Extract request IDs from incoming headers as well. Can be used for
+      # identifying a request across a number of components in SOA.
+      env["REQUEST_IDS"] = request_ids
+
+      status, headers, response = @app.call(env)
+
+      # tag all responses with a request ID
+      headers["Request-Id"] = request_ids[0]
+
+      [status, headers, response]
+    end
+
+    private
+
+    def extract_request_ids(env)
+      request_ids = []
+      if env["HTTP_REQUEST_ID"]
+        request_ids = env["HTTP_REQUEST_ID"].split(",")
+        request_ids.map! { |id| id.strip }
+        request_ids.select! { |id| id =~ UUID_PATTERN }
+      end
+      request_ids
+    end
+  end
+end

data/lib/pliny/middleware/request_store.rb

@@ -0,0 +1,14 @@
+module Pliny::Middleware
+  class RequestStore
+    def initialize(app, options={})
+      @app = app
+      @store = options[:store] || Pliny::RequestStore
+    end
+
+    def call(env)
+      @store.clear!
+      @store.seed(env)
+      @app.call(env)
+    end
+  end
+end

data/lib/pliny/middleware/rescue_errors.rb

@@ -0,0 +1,24 @@
+module Pliny::Middleware
+  class RescueErrors
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Pliny::Errors::Error => e
+      render(e, env)
+    rescue Exception => e
+    # Pliny.log_exception(e)
+      render(Pliny::Errors::InternalServerError.new, env)
+    end
+
+    private
+
+    def render(e, env)
+      headers = { "Content-Type" => "application/json; charset=utf-8" }
+      error = { id: e.id, message: e.message, status: e.status }
+      [e.status, headers, [MultiJson.encode(error)]]
+    end
+  end
+end

data/lib/pliny/middleware/timeout.rb

@@ -0,0 +1,25 @@
+require "timeout"
+
+module Pliny::Middleware
+  # Requires that Pliny::Middleware::RescueErrors is nested above it.
+  class Timeout
+    def initialize(app, options={})
+      @app = app
+      @timeout = options[:timeout] || 45
+    end
+
+    def call(env)
+      ::Timeout.timeout(@timeout, RequestTimeout) do
+        @app.call(env)
+      end
+    rescue RequestTimeout
+    # Pliny::Sample.measure "requests.timeouts"
+      raise Pliny::Errors::ServiceUnavailable, "Timeout reached."
+    end
+
+    # use a custom Timeout class so it can't be rescued accidentally by
+    # internal calls
+    class RequestTimeout < Exception
+    end
+  end
+end

data/lib/pliny/middleware/versioning.rb

@@ -0,0 +1,64 @@
+require 'http_accept'
+
+module Pliny::Middleware
+  class Versioning
+    def initialize(app, options={})
+      @app = app
+      @default = options[:default] || raise("missing=default")
+      @app_name = options[:app_name] || raise("missing=app_name")
+    end
+
+    def call(env)
+      Pliny.log middleware: :versioning, id: env["REQUEST_ID"] do
+        detect_api_version(env)
+      end
+    end
+
+    private
+
+    def detect_api_version(env)
+      media_types = HTTPAccept.parse(env["HTTP_ACCEPT"])
+
+      version = nil
+      media_types.map! do |media_type|
+        if accept_headers.include?(media_type.format)
+          if !media_type.params["version"]
+            error = { id: :bad_version, message: <<-eos }
+Please specify a version along with the MIME type. For example, `Accept: application/vnd.#{@app_name}+json; version=1`.
+            eos
+            return [400, { "Content-Type" => "application/json; charset=utf-8" },
+              [MultiJson.encode(error)]]
+          end
+
+          if !version
+            version = media_type.params["version"]
+          end
+
+          # replace the MIME with a simplified version for easier
+          # parsing down the stack
+          media_type.format = "application/json"
+          media_type.params.delete("version")
+        end
+        media_type.to_s
+      end
+      env["HTTP_ACCEPT"] = media_types.map(&:to_s).join(", ")
+
+      version ||= @default
+      set_api_version(env, version)
+      @app.call(env)
+    end
+
+    def set_api_version(env, version)
+      # API modules will look for the version in env
+      env["HTTP_X_API_VERSION"] = version
+    end
+
+    def accept_headers
+      [
+        "application/vnd.#{@app_name}",
+        "application/vnd.#{@app_name}+json",
+        "application/*+json",
+      ]
+    end
+  end
+end

data/lib/pliny/request_store.rb

@@ -0,0 +1,22 @@
+module Pliny
+  module RequestStore
+    def self.clear!
+      Thread.current[:request_store] = {}
+    end
+
+    def self.seed(env)
+      store[:request_id] =
+        env["REQUEST_IDS"] ? env["REQUEST_IDS"].join(",") : nil
+
+      # a global context that evolves over the lifetime of the request, and is
+      # used to tag all log messages that it produces
+      store[:log_context] = {
+        request_id: store[:request_id]
+      }
+    end
+
+    def self.store
+      Thread.current[:request_store] ||= {}
+    end
+  end
+end

data/lib/pliny/router.rb

@@ -0,0 +1,15 @@
+require 'sinatra/router'
+
+module Pliny
+  class Router < Sinatra::Router
+
+    # yield to a builder block in which all defined apps will only respond for
+    # the given version
+    def version(*versions, &block)
+      condition = lambda { |env|
+        versions.include?(env["HTTP_X_API_VERSION"])
+      }
+      with_conditions(condition, &block)
+    end
+  end
+end

data/lib/pliny/tasks.rb

@@ -0,0 +1,3 @@
+Dir[File.expand_path("../tasks", __FILE__) + "/*.rake"].sort.each do |f|
+  load(f)
+end

data/lib/pliny/tasks/db.rake

@@ -0,0 +1,116 @@
+require "sequel"
+require "sequel/extensions/migration"
+require "uri"
+
+require "pliny/utils"
+
+namespace :db do
+  desc "Run database migrations"
+  task :migrate do
+    next if Dir["./db/migrate/*.rb"].empty?
+    database_urls.each do |database_url|
+      db = Sequel.connect(database_url)
+      Sequel::Migrator.apply(db, "./db/migrate")
+      puts "Migrated `#{name_from_uri(database_url)}`"
+    end
+  end
+
+  desc "Rollback the database"
+  task :rollback do
+    next if Dir["./db/migrate/*.rb"].empty?
+    database_urls.each do |database_url|
+      db = Sequel.connect(database_url)
+      Sequel::Migrator.apply(db, "./db/migrate", -1)
+      puts "Rolled back `#{name_from_uri(database_url)}`"
+    end
+  end
+
+  desc "Nuke the database (drop all tables)"
+  task :nuke do
+    database_urls.each do |database_url|
+      db = Sequel.connect(database_url)
+      db.tables.each do |table|
+        db.run(%{DROP TABLE "#{table}"})
+      end
+      puts "Nuked `#{name_from_uri(database_url)}`"
+    end
+  end
+
+  desc "Reset the database"
+  task :reset => [:nuke, :migrate]
+
+  desc "Create the database"
+  task :create do
+    db = Sequel.connect("postgres://localhost/postgres")
+    database_urls.each do |database_url|
+      exists = false
+      name = name_from_uri(database_url)
+      begin
+        db.run(%{CREATE DATABASE "#{name}"})
+      rescue Sequel::DatabaseError
+        raise unless $!.message =~ /already exists/
+        exists = true
+      end
+      puts "Created `#{name}`" if !exists
+    end
+  end
+
+  desc "Drop the database"
+  task :drop do
+    db = Sequel.connect("postgres://localhost/postgres")
+    database_urls.each do |database_url|
+      name = name_from_uri(database_url)
+      db.run(%{DROP DATABASE IF EXISTS "#{name}"})
+      puts "Dropped `#{name}`"
+    end
+  end
+
+  namespace :schema do
+    desc "Load the database schema"
+    task :load do
+      schema = File.read("./db/schema.sql")
+      database_urls.each do |database_url|
+        db = Sequel.connect(database_url)
+        db.run(schema)
+        puts "Loaded `#{name_from_uri(database_url)}`"
+      end
+    end
+
+    desc "Dump the database schema"
+    task :dump do
+      database_url = database_urls.first
+      `pg_dump -i -s -x -O -f ./db/schema.sql #{database_url}`
+      puts "Dumped `#{name_from_uri(database_url)}` to db/schema.sql"
+    end
+
+    desc "Merges migrations into schema and removes them"
+    task :merge => ["db:setup", "db:schema:load", "db:migrate", "db:schema:dump"] do
+      FileUtils.rm Dir["./db/migrate/*.rb"]
+      puts "Removed migrations"
+    end
+  end
+
+  desc "Setup the database"
+  task :setup => [:drop, :create]
+
+  private
+
+  def database_urls
+    if ENV["DATABASE_URL"]
+      [ENV["DATABASE_URL"]]
+    else
+      %w(.env .env.test).map { |env_file|
+        env_path = "./#{env_file}"
+        if File.exists?(env_path)
+          Pliny::Utils.parse_env(env_path)["DATABASE_URL"]
+        else
+          nil
+        end
+      }.compact
+    end
+  end
+
+  def name_from_uri(uri)
+    URI.parse(uri).path[1..-1]
+  end
+end

data/lib/pliny/tasks/test.rake

@@ -0,0 +1,8 @@
+require "rake/testtask"
+
+Rake::TestTask.new do |task|
+  task.libs << "lib"
+  task.libs << "test"
+  task.name = :test
+  task.test_files = FileList["test/**/*_test.rb"]
+end

data/lib/pliny/templates/endpoint.erb

@@ -0,0 +1,30 @@
+module Endpoints
+  class <%= plural_class_name %> < Base
+    namespace "<%= url_path %>" do
+      before do
+        content_type :json
+      end
+
+      get do
+        "[]"
+      end
+
+      post do
+        status 201
+        "{}"
+      end
+
+      get "/:id" do
+        "{}"
+      end
+
+      patch "/:id" do |id|
+        "{}"
+      end
+
+      delete "/:id" do |id|
+        "{}"
+      end
+    end
+  end
+end

data/lib/pliny/templates/endpoint_acceptance_test.erb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Endpoints::<%= plural_class_name %> do
+  include Committee::Test::Methods
+  include Rack::Test::Methods
+
+  def app
+    Routes
+  end
+
+  it "GET <%= url_path %>" do
+    get "<%= url_path %>"
+    last_response.status.should eq(200)
+    last_response.body.should eq("[]")
+  end
+
+  it "POST <%= url_path %>/:id" do
+    post "<%= url_path %>"
+    last_response.status.should eq(201)
+    last_response.body.should eq("{}")
+  end
+
+  it "GET <%= url_path %>/:id" do
+    get "<%= url_path %>/123"
+    last_response.status.should eq(200)
+    last_response.body.should eq("{}")
+  end
+
+  it "PATCH <%= url_path %>/:id" do
+    patch "<%= url_path %>/123"
+    last_response.status.should eq(200)
+    last_response.body.should eq("{}")
+  end
+
+  it "DELETE <%= url_path %>/:id" do
+    delete "<%= url_path %>/123"
+    last_response.status.should eq(200)
+    last_response.body.should eq("{}")
+  end
+end