accelerator 0.1.0

data/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+logs
+nginx/*_temp
+pkg
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+#Nginx Accelerator
+
+Drop-in page caching using nginx, lua, and memcached.
+
+##Features
+
+* Listens to Cache-Control max-age header
+* The memcached key is the URI (easy to expire on demand)
+* Really, really fast
+
+##Requirements
+
+Nginx build with the following modules:
+
+* [LuaJIT](http://wiki.nginx.org/HttpLuaModule)
+* [MemcNginxModule](http://wiki.nginx.org/HttpMemcModule)
+* [LuaRestyMemcachedLibrary](https://github.com/agentzh/lua-resty-memcached)
+
+See the [Building OpenResty](#building-openresty) section below for instructions.
+
+##Install
+
+    luarocks install nginx-accelerator
+
+##Nginx config
+
+Drop the following line in any `location` directive within `nginx.conf`:
+
+    access_by_lua "require('accelerator').access()";
+
+For example:
+
+    http {
+      server {
+        listen 8080;
+
+        location = / {
+          access_by_lua "require('accelerator').access()";
+        }
+      }
+    }
+
+The TTL is based on `Cache-Control: max-age`, but defaults to 10 seconds.
+
+To configure your memcached connection information:
+
+	access_by_lua "require('accelerator').access({ host='127.0.0.1', port=11211 })";
+
+## Ruby client
+
+### Install gem
+
+	gem install accelerator
+
+### Example
+
+	cache = Accelerator.new("localhost:11211")
+	cache.get("/test")
+	cache.set("/test", "body")
+	cache.delete("/test")
+	cache.expire("/test", 10)
+
+## Running specs
+
+###Install Lua
+
+	brew install lua
+	brew install luarocks
+
+###Install PCRE
+
+	brew update
+	brew install pcre
+
+###Install [OpenResty](http://openresty.org) (nginx)
+
+	curl -O http://agentzh.org/misc/nginx/ngx_openresty-1.2.4.9.tar.gz
+	tar xzvf ngx_openresty-1.2.4.9.tar.gz
+	cd ngx_openresty-1.2.4.9/
+
+Get your PCRE version:
+
+	brew info pcre
+
+Replace **VERSION** below with the PCRE version:
+
+	./configure --with-luajit --with-cc-opt="-I/usr/local/Cellar/pcre/VERSION/include" --with-ld-opt="-L/usr/local/Cellar/pcre/VERSION/lib"
+	make
+	make install
+
+###Start nginx
+
+	cd nginx-accelerator
+	./nginx/start
+
+### Run specs
+
+	bundle install
+	spec spec

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/accelerator

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require File.expand_path("../../lib/accelerator", __FILE__)

data/build

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+cd src
+
+if [ "$1" == "watch" ]
+then
+	moonc -t ../lib -w .
+else
+	moonc -t ../lib .
+fi

data/lib/accelerator.lua

@@ -0,0 +1,95 @@
+module("accelerator", package.seeall)
+local json = require("cjson")
+local memcached = require("resty.memcached")
+local debug
+debug = function(kind, msg)
+  if msg then
+    msg = kind .. ": " .. msg
+  else
+    msg = kind
+  end
+  return ngx.log(ngx.DEBUG, msg)
+end
+local memclient
+memclient = function(opts)
+  if opts == nil then
+    opts = { }
+  end
+  local client, err = memcached:new()
+  if not client or err then
+    error(err or "problem creating client")
+  end
+  client:set_timeout(1000)
+  local ok
+  ok, err = client:connect((opts.host or "127.0.0.1"), (opts.port or 11211))
+  if not ok or err then
+    error(err or "problem connecting")
+  end
+  return client
+end
+local access
+access = function(opts)
+  if ngx.var.request_method ~= "GET" then
+    return 
+  end
+  if ngx.is_subrequest then
+    return 
+  end
+  local fn
+  fn = function()
+    local memc = memclient(opts)
+    local cache, flags, err = memc:get(ngx.var.request_uri)
+    if err then
+      error(err)
+    end
+    if cache then
+      debug("read cache", cache)
+      cache = json.decode(cache)
+      if cache.header then
+        ngx.header = cache.header
+      end
+      if cache.body then
+        ngx.say(cache.body)
+      end
+    end
+    if not cache or os.time() - cache.time >= cache.ttl then
+      local co = coroutine.create(function()
+        cache = cache or { }
+        cache.time = os.time()
+        memc:set(ngx.var.request_uri, json.encode(cache))
+        local res = ngx.location.capture(ngx.var.request_uri)
+        if not res then
+          return 
+        end
+        local ttl = nil
+        do
+          local cc = res.header["Cache-Control"]
+          if cc then
+            res.header["Cache-Control"] = nil
+            local x, x
+            x, x, ttl = string.find(cc, "max%-age=(%d+)")
+          end
+        end
+        if ttl then
+          ttl = tonumber(ttl)
+          debug("ttl", ttl)
+        end
+        res.time = os.time()
+        res.ttl = ttl or opts.ttl or 10
+        memc:set(ngx.var.request_uri, json.encode(res))
+        return debug("write cache")
+      end)
+      coroutine.resume(co)
+    end
+    if cache and cache.body then
+      return ngx.exit(ngx.HTTP_OK)
+    end
+  end
+  local status, err = pcall(fn)
+  if err then
+    return ngx.log(ngx.ERR, err)
+  end
+end
+return {
+  access = access
+}

data/lib/accelerator.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'cgi'
+require 'json'
+require 'memcached'
+
+class Accelerator
+
+  def initialize(host="localhost:11211")
+    @memc = Memcached.new(host)
+  end
+
+  def delete(uri)
+    @memc.delete(key(uri))
+  end
+
+  def expire(uri, ttl=nil)
+    if data = get_and_set_time(uri)
+      data[:ttl] = ttl if ttl
+      data[:time] -= data[:ttl] || 10
+      @memc.set(key(uri), data.to_json, 604800, false)
+    end
+  end
+
+  def get(uri)
+    if data = get_and_parse(uri)
+      [ data.delete(:body), data ]
+    end
+  end
+
+  def set(uri, body)
+    data = get_and_set_time(uri) || { :time => Time.now.to_i }
+    data[:body] = body
+    @memc.set(key(uri), data.to_json, 604800, false)
+  end
+
+  private
+
+  def key(k)
+    CGI.escape(k).gsub(/%../) { |s| s.downcase }
+  end
+
+  def get_and_parse(uri)
+    data = @memc.get(key(uri), nil) rescue nil
+    if data
+      JSON.parse(data, :symbolize_names => true)
+    end
+  end
+
+  def get_and_set_time(uri)
+    if data = get_and_parse(uri)
+      data[:time] = Time.now.to_i
+    end
+    data
+  end
+end

data/nginx/nginx.conf

@@ -0,0 +1,34 @@
+worker_processes  1;
+error_log logs/error.log debug;
+events {
+	worker_connections 1024;
+}
+http {
+	server {
+		listen 8080;
+
+		location = /test {
+
+			access_by_lua "
+			  ngx.log(ngx.DEBUG, 'ACCESS PHASE')
+			  require('accelerator').access({ host='127.0.0.1', port=11211 })
+			";
+
+			proxy_pass http://127.0.0.1:8081/;
+		}
+	}
+
+	server {
+		listen 8081;
+
+		location = / {
+
+			more_set_headers "Cache-Control: max-age=1";
+
+			content_by_lua "
+			  ngx.log(ngx.DEBUG, 'CONTENT PHASE')
+			  ngx.say(os.time())
+			";
+		}
+	}
+}

data/nginx/start

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+./build
+luarocks make
+PATH=/usr/local/openresty/nginx/sbin:$PATH
+export PATH
+nginx -p `pwd`/nginx/ -c nginx.conf -s stop
+nginx -p `pwd`/nginx/ -c nginx.conf
+tail -f nginx/logs/error.log

data/nginx-accelerator-1.0-1.rockspec

@@ -0,0 +1,24 @@
+package = "nginx-accelerator"
+version = "1.0-1"
+source = {
+   url = "http://github.com/winton/nginx-accelerator"
+}
+description = {
+   summary = "Nginx-level memcaching for fun and profit",
+   detailed = [[
+      Uses information from Cache-Control headers to memcache responses
+      at the nginx level.
+   ]],
+   homepage = "http://github.com/winton/nginx-accelerator",
+   license = "MIT"
+}
+dependencies = {
+   "lua >= 5.1",
+   "lua-cjson >= 2.1.0-1"
+}
+build = {
+   type = "builtin",
+   modules = {
+      ["accelerator"] = "lib/accelerator.lua"
+   }
+}

data/nginx-accelerator.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+root = File.expand_path('../', __FILE__)
+lib = "#{root}/lib"
+
+$:.unshift lib unless $:.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name        = "accelerator"
+  s.version     = '0.1.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [ "Winton Welsh" ]
+  s.email       = [ "mail@wintoni.us" ]
+  s.homepage    = "http://github.com/winton/nginx-accelerator"
+  s.summary     = %q{Drop-in page caching using nginx, lua, and memcached}
+  s.description = %q{Drop-in page caching using nginx, lua, and memcached.}
+
+  s.executables = `cd #{root} && git ls-files bin/*`.split("\n").collect { |f| File.basename(f) }
+  s.files = `cd #{root} && git ls-files`.split("\n")
+  s.require_paths = %w(lib)
+  s.test_files = `cd #{root} && git ls-files -- {features,test,spec}/*`.split("\n")
+
+  s.add_dependency "memcached", "~> 1.5.0"
+  s.add_development_dependency "rspec", "~> 1.0"
+end

data/spec/accelerator_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Accelerator do
+
+  before(:all) do
+    @accelerator = Accelerator.new
+    @accelerator.delete("/test")
+  end
+
+  it "should create cache on first request" do
+    time = Time.new.to_i
+    request.should == time
+    body, options = @accelerator.get("/test")
+    response_tests(time)
+  end
+
+  it "should return same cache on next request" do
+    $expires_at = Time.now.to_f.ceil
+    request.should == $last_time
+    body, options = @accelerator.get("/test")
+    response_tests($last_time)
+  end
+
+  it "should not expire naturally before 1 second" do
+    if Time.now.to_f < $expires_at
+      expires_in = $expires_at - Time.now.to_f
+      request(0.5 * expires_in).should == $last_time
+    end
+  end
+
+  it "should expire naturally after 1 second" do
+    if Time.now.to_f < $expires_at
+      expires_in = $expires_at - Time.now.to_f
+      request(expires_in).should == $last_time
+    end
+    response_tests(Time.new.to_i)
+  end
+
+  it "should obey client expiration" do
+    @accelerator.expire("/test")
+    request.should == $last_time
+    response_tests($last_time)
+  end
+
+  it "should set cache body from the client" do
+    @accelerator.set("/test", "123")
+    $expires_at = Time.now.to_f.ceil
+    request.should == 123
+  end
+
+  it "should not expire naturally before 1 second" do
+    if Time.now.to_f < $expires_at
+      expires_in = $expires_at - Time.now.to_f
+      request(0.5 * expires_in).should == 123
+    end
+  end
+
+  it "should expire naturally after 1 second" do
+    if Time.now.to_f < $expires_at
+      expires_in = $expires_at - Time.now.to_f
+      request(expires_in).should == 123
+    end
+    response_tests(Time.new.to_i)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require "pp"
+require "bundler"
+
+Bundler.require(:development)
+
+$root = File.expand_path('../../', __FILE__)
+
+require "#{$root}/lib/accelerator"
+
+def request(wait=nil)
+  sleep(wait) if wait
+  `curl -s http://localhost:8080/test`.strip.to_i
+end
+
+def response_tests(time)
+  $last_time = time
+  body, options = @accelerator.get("/test")
+  body.strip.should == time.to_s
+  options.should == {
+    :ttl => 1,
+    :status => 200,
+    :header => { 
+      :"Content-Length" => 11,
+      :"Content-Type" => "text/plain"
+    },
+    :time => time
+  }
+end

data/src/accelerator.moon

@@ -0,0 +1,99 @@
+module "accelerator", package.seeall
+
+
+-- Dependencies
+
+json      = require "cjson"
+memcached = require "resty.memcached"
+
+
+-- Debug log
+
+debug = (kind, msg) ->
+  msg = if msg then kind .. ": " .. msg else kind
+  ngx.log(ngx.DEBUG, msg)
+
+
+-- Create memcached client
+
+memclient = (opts={}) ->
+  client, err = memcached\new()
+  error(err or "problem creating client") if not client or err
+
+  -- Set memcached connection timeout to 1 sec
+  client\set_timeout(1000)
+
+  -- Connect to memcached server
+  ok, err = client\connect((opts.host or "127.0.0.1"), (opts.port or 11211))
+  error(err or "problem connecting") if not ok or err
+
+  client
+
+
+-- Execute within access_by_lua:
+-- http://wiki.nginx.org/HttpLuaModule#access_by_lua
+
+access = (opts) ->
+  return if ngx.var.request_method ~= "GET"
+  return if ngx.is_subrequest
+
+  fn = ->
+    memc = memclient(opts)
+
+    cache, flags, err = memc\get(ngx.var.request_uri)
+    error(err) if err
+
+    if cache
+      debug("read cache", cache)
+      cache = json.decode(cache)
+      
+      if cache.header
+        ngx.header = cache.header
+
+      if cache.body
+        ngx.say(cache.body)
+    
+    -- Rewrite cache if cache does not exist or ttl has expired
+    if not cache or os.time() - cache.time >= cache.ttl
+      co = coroutine.create ->
+
+        -- Immediately update the time to prevent multiple writes
+        cache = cache or {}
+        cache.time = os.time()
+        memc\set(ngx.var.request_uri, json.encode(cache))
+
+        -- Make subrequest
+        res = ngx.location.capture(ngx.var.request_uri)
+        return if not res
+
+        -- Parse TTL
+        ttl = nil
+
+        if cc = res.header["Cache-Control"]
+          res.header["Cache-Control"] = nil
+          x, x, ttl = string.find(cc, "max%-age=(%d+)")
+
+        if ttl
+          ttl = tonumber(ttl)
+          debug("ttl", ttl)
+
+        res.time = os.time()
+        res.ttl  = ttl or opts.ttl or 10
+
+        -- Write cache
+        memc\set(ngx.var.request_uri, json.encode(res))
+        debug("write cache")
+
+      coroutine.resume(co)
+
+    -- Prevent further phases from executing if body rendered
+    if cache and cache.body
+      ngx.exit(ngx.HTTP_OK)
+
+  status, err = pcall(fn)
+  ngx.log(ngx.ERR, err) if err
+
+
+-- Return
+
+return { access: access }

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: accelerator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Winton Welsh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: memcached
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Drop-in page caching using nginx, lua, and memcached.
+email:
+- mail@wintoni.us
+executables:
+- accelerator
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/accelerator
+- build
+- lib/accelerator.lua
+- lib/accelerator.rb
+- nginx-accelerator-1.0-1.rockspec
+- nginx-accelerator.gemspec
+- nginx/nginx.conf
+- nginx/start
+- spec/accelerator_spec.rb
+- spec/spec_helper.rb
+- src/accelerator.moon
+homepage: http://github.com/winton/nginx-accelerator
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Drop-in page caching using nginx, lua, and memcached
+test_files:
+- spec/accelerator_spec.rb
+- spec/spec_helper.rb