offshore 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use ruby-1.9.3-p194@offshore --install --create
+export PATH=./bin:$PATH

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'json_pure'
+
+# Specify your gem's dependencies in offshore.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Brian Leonard
+
+MIT License
+
+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,111 @@
+# Offshore
+
+For when you need a remote factory.
+Let's say you love testing, but your app heavily depends on another app and it's data in a certain format. You have API and/or database access to this data.
+
+Offshore allows you use the factories of that app within your test suite as well as adds transactional support to the database of that app so that each test starts with the same fixtures.
+
+#### Notes
+
+* For now, this only works on MySQL databases
+* Redis is needed to run as well
+
+## Server
+
+The server app is the one with the factories and the database that your app needs to work.
+For Rails, add this to your Gemfile:
+
+    group :test do
+      gem 'offshore'
+    end
+    
+You might need something like this to your test.rb application config:
+
+    Offshore.redis = "localhost:6379"
+
+Then run something like this on the command line
+
+    rails s thin -e test -p 4111
+
+In you want it anything but blank, you must create a rake task called offshore:seed that creates the test database referenced in the database.yml file in the test environment.
+Something like this would work.
+
+    namespace :offshore do
+      task :preload do
+        ENV['RAILS_ENV'] = "test"
+      end
+      task :setup => :environment
+  
+      desc "seeds the db for offshore gem"
+      task :seed do
+        Rake::Task['db:migrate'].invoke
+        Rake::Task['db:test:prepare'].invoke
+        Rake::Task['db:seed'].invoke
+      end
+    end
+
+The :preload and :setup steps will be invoked in that order before your :seed call. They are actually unnecessary here, but shown in case you have something more complex to do.
+
+#### Notes
+
+* For other Rack apps, you should be able to use Offshore::Middleware directly.
+* This middleware is included automatically in Rails via Railties.
+* The server is meant to be a singular resource accessed by many test threads (parallelization of tests). It accomplishes this through a mutex and polling its availability.
+
+
+
+## Client
+
+The client app is the one running the tests.
+
+The same thing in the Gemfile:
+
+    group :test do
+      gem 'offshore'
+    end
+    
+The Rspec config looks likes this:
+
+    config.before(:suite) do
+      Offshore.suite.start(:host => "localhost", :port => 4111)
+    end
+
+    config.before(:each) do
+      Offshore.test.start(example)
+    end
+
+    config.after(:each) do
+      Offshore.test.stop(example)
+    end
+
+    config.after(:suite) do
+      Offshore.suite.stop
+    end
+
+Then in your test you can do:
+
+    user = FactoryOffshore.create(:user, :first_name => "Johnny")
+    user.first_name.should == "Johnny"
+    user.class.should == ::User
+
+This assumes that you have a class by the same name the the :user factory made from the server that responds to find() with the id created on the server.
+
+You can send :snapshot => false to Offshore.suite.start to prevent rolling back before the test. 
+Note, this will leave your suite in a somewhat unpredictable state especially when you consider there are other suites that might be rolling that database back. 
+However, this may be preferable if your database is very large. On small (50 tables / 1000 rows) databases, the difference in time seems to be noise. Some efforts are taken (checksum) to not rollback if the test did not change the database.
+
+
+#### Notes
+
+* You can also make API requests.
+* You get a fresh database each time by default.
+
+## TODO
+
+* Use binlogs if enabled for even faster MySQL rollback
+* Configure custom lookups for the hash returned with the created data
+* Configure custom paths (defaults to /offshore_tests now)
+* Anything else need to be cleared out each test? i.e. redis, memcache, etc
+* Other DB support
+* Other MySQL adapter support
+

data/Rakefile

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift 'lib'
+require 'offshore/tasks'

data/lib/offshore/client/factory_offshore.rb

@@ -0,0 +1,8 @@
+class FactoryOffshore
+  def self.create(*args)
+    host = Offshore.suite.default
+    host.factory_create(*args)
+  end
+  
+  # TODO: multiple hosts  
+end

data/lib/offshore/client/host.rb

@@ -0,0 +1,110 @@
+require "faraday"
+
+module Offshore
+  class Host
+#    def client
+#      return @http if @http
+#      @http = Net::HTTP.new(host, port)
+#      # @http.use_ssl = true
+#      # @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+#      @http
+#    end
+#    
+#    def post(append_path, attributes)
+#      request = Net::HTTP::Post.new()
+#      request.set_form_data(attributes)
+#      response = client.request(request)
+#      response.value
+#      JSON.parse(response.body)
+#    end
+
+    def base_uri
+      with_http = host
+      with_http = "http://#{host}" unless (host =~ /^https?:/) == 0
+      need_port = port || 80
+      "#{with_http}:#{need_port}"
+    end
+  
+    def connection
+      return @connection if @connection
+      connection_class = Faraday.respond_to?(:new) ? ::Faraday : ::Faraday::Connection
+
+      timeout_seconds = 5*60 # 5 minutes
+      @connection = connection_class.new(base_uri, :timeout => timeout_seconds) do |builder|
+        builder.use Faraday::Request::UrlEncoded  if defined?(Faraday::Request::UrlEncoded)
+        builder.adapter Faraday.default_adapter
+      end
+      @connection
+    end
+    
+    def post(append_path, attributes={})
+      attributes[:hostname] = `hostname`  # always send hostname
+      
+      while true do
+        http_response = connection.post("#{self.path}/#{append_path}", attributes)
+        if http_response.success?
+          return MultiJson.decode(http_response.body)
+        elsif http_response.status.to_s == Offshore::WAIT_CODE.to_s
+          sleep 2 # two seconds and try again
+        else
+          begin
+            hash = MultiJson.decode(http_response.body)
+            message = "Error in offshore connection (#{append_path}): #{hash}"
+          rescue
+            message = "Error in offshore connection (#{append_path}): #{http_response.status}"
+          end
+          raise message
+        end
+      end
+    end
+    
+    attr_reader :host, :port
+    def initialize(options)
+      @host = options[:host]
+      @port = options[:port]
+      @path = options[:path]
+      @snapshot = options[:snapshot]
+    end
+    
+    def snapshot_name
+      return nil if @snapshot == true
+      return "none" if @snapshot == false
+      @snapshot
+    end
+    
+    def path
+      @path ||= "/offshore_tests"
+    end
+    
+    def suite_start
+      attributes = {}
+      attributes[:snapshot] = snapshot_name
+      hash = post(:suite_start, attributes)
+    end
+    
+    def suite_stop
+      hash = post(:suite_stop)
+    end
+    
+    def test_start(name)
+      hash = post(:test_start, { :name => name })
+    end
+    
+    def test_stop(name)
+      hash = post(:test_stop, { :name => name })
+    end
+    
+    def factory_create(name, attributes={})
+      data = { :name => name }
+      data[:attributes] = attributes
+      hash = post(:factory_create, data)
+      factory_object(hash)
+    end
+    
+    # TODO: move this to a config block
+    def factory_object(hash)
+      hash["class_name"].constantize.find(hash["id"])
+    end
+    
+  end
+end

data/lib/offshore/client/suite.rb

@@ -0,0 +1,33 @@
+module Offshore
+  class Suite
+    def hosts
+      @hosts ||= []
+    end
+    
+    def default
+      hosts.first
+    end
+    
+    def all_hosts!(method, *args)
+      hosts.each do |host|
+        host.send(method, *args)
+      end
+    end
+  
+    def start(server_array_or_hash)
+      server_array = server_array_or_hash.is_a?(Array) ? server_array_or_hash : [server_array_or_hash]
+      raise "Need one server" if server_array.size != 1
+      
+      server_array.each do |hash|
+        hosts << Host.new(hash)
+      end
+      
+      all_hosts!(:suite_start)
+    end
+  
+    def stop
+      Offshore.test # if the last one failed this will stop it
+      all_hosts!(:suite_stop)
+    end
+  end
+end

data/lib/offshore/client/test.rb

@@ -0,0 +1,39 @@
+module Offshore
+  class Test
+    def uuid
+      @uid ||= rand(99999999).to_s
+    end
+    
+    def get_name(example)
+      name = nil
+      name = example.full_description if example.respond_to?(:full_description)
+      name ||= "unknown"
+      "#{uuid} #{name}"
+    end
+    
+    def run!(example)
+      raise "already run test: #{get_name(@run_example)}" if @run_example
+      @run_example = example
+    end
+    
+    def run?
+      !!@run_example
+    end
+
+    def start(example=nil)
+      run!(example)
+      Offshore.suite.all_hosts!(:test_start, get_name(example))
+    end
+  
+    def stop(example=nil)
+      Offshore.suite.all_hosts!(:test_stop, get_name(example))
+      Offshore.send(:internal_test_ended)
+    end
+    
+    def failed
+      raise "have not run!" unless @run_example
+      stop(@run_example)
+    end
+  
+  end
+end

data/lib/offshore/client.rb

@@ -0,0 +1,4 @@
+require "offshore/client/host"
+require "offshore/client/suite"
+require "offshore/client/test"
+require "offshore/client/factory_offshore"

data/lib/offshore/server/controller.rb

@@ -0,0 +1,81 @@
+module Offshore
+  class Controller
+    attr_reader :params
+    def initialize(hash)
+      @params = hash
+    end
+    
+    def suite_start
+      suite_key_set(params)
+      [200, {"todo" => "log that the suite is running"}]
+    end
+    
+    def suite_stop
+      suite_key_clear
+      [200, {"action" => "cleared"}]
+    end
+    
+    def test_start
+      Logger.info("  Start: #{params["name"]}")
+      Offshore::Database.lock
+      Offshore::Database.rollback if suite_key_options["snapshot"] != "none"
+      [200, {"action" => "reset / lock"}]
+    end
+    
+    def test_stop
+      Logger.info("   Stop: #{params["name"]}")
+      Offshore::Database.unlock
+      [200, {"action" => "unlocked"}]
+    end
+    
+    def factory_create      
+      name = params["name"]
+      raise "Need a factory name" unless name
+      attributes = params["attributes"] || {}
+      
+      clazz = factory_girl
+      require "factory_girl" unless clazz
+      clazz = factory_girl
+      
+      begin
+        val = clazz.create(name, attributes)
+        out = {:class_name => val.class.name, :id => val.id, :attributes => val.attributes}
+        status = 200
+      rescue ActiveRecord::RecordInvalid => invalid
+        out = {:error => invalid.record.errors.full_messages.join(",") }
+        status = 422
+      end
+      [status, out]
+    end
+    
+    private
+    
+    def factory_girl
+      if defined? FactoryGirl
+        return FactoryGirl
+      elsif defined? Factory
+        return Factory
+      end
+      return nil
+    end
+    
+    def suite_key_set(val)
+      Offshore.redis.set(suite_key, MultiJson.encode(val))
+      @suite_key_options = nil
+    end
+    
+    def suite_key_clear
+      Offshore.redis.del(suite_key)
+    end
+    
+    def suite_key_options
+      @suite_key_options ||= MultiJson.decode(Offshore.redis.get(suite_key) || "{}")
+    end
+    
+    def suite_key
+      raise "need a hostname" unless params["hostname"]
+      "suite:#{params["hostname"]}:options"
+    end
+
+  end
+end

data/lib/offshore/server/database.rb

@@ -0,0 +1,111 @@
+module Offshore
+  module Database
+    extend self
+    
+    GENERATE_KEY = "database:generate"
+    LOCK_KEY = "database:lock"
+    SHUTDOWN_KEY = "database:shutdown"
+    SUITES_LIST_KEY = "suites:list"
+    
+    def redis
+      Offshore.redis
+    end
+    
+    def lock
+      Logger.info(" Database.lock")
+      if Offshore::Mutex.lock(LOCK_KEY)
+        Logger.info("    .... lock acquired")
+      else
+        Logger.info("    .... locked")
+        raise Offshore::CheckBackLater.new("Database in use")
+      end
+    end
+    
+    def unlock
+      Logger.info(" Database.unlock")
+      Offshore::Mutex.unlock!(LOCK_KEY)
+    end
+    
+    def reset
+      Logger.info(" Database.reset")
+      redis.del(LOCK_KEY)
+      redis.del(GENERATE_KEY)
+      redis.del(SHUTDOWN_KEY)
+      redis.del(SUITES_LIST_KEY)
+    end
+    
+    def startup(background=true)
+      Logger.info(" Database.startup")
+      reset
+      create_schema(background)
+    end
+    
+    def shutdown
+      Logger.info(" Database.shutdown")
+      redis.incr(SHUTDOWN_KEY, 1)
+    end
+    
+    def init
+      # TODO: how to let these finish and also stall startup.
+      # should it be per test
+      # what about db reconnections?
+      Logger.info(" Database.init")
+      if redis.get(SHUTDOWN_KEY)
+        Logger.info("   .... databse shutting down. Exiting.")
+        raise "Database shutting down. No new connections, please."
+      else
+        create_schema(true)
+      end
+    end
+    
+    def schema_snapshot
+      Logger.info(" Database.schema_snapshot")
+      snapshot.create
+    end
+    
+    def rollback
+      Logger.info(" Database.rollback")
+      snapshot.rollback
+    end
+        
+    private
+    
+    def create_schema(background)
+      times = redis.incr(GENERATE_KEY) # get the incremented counter value      
+      unless times == 1
+        Logger.info("   Database.create_schema: already created")
+        return
+      end
+      
+      Logger.info("   Database.create_schema: creating....")
+      lock
+      if background
+        build_in_fork
+      else
+        build_in_process
+      end
+    end
+    
+    
+    def build_in_fork
+      Logger.info("    ..... building in fork")
+      otherProcess = fork { `bundle exec rake offshore:seed_schema --trace`; `bundle exec rake offshore:unlock --trace`; }
+      Process.detach(otherProcess)
+    end
+    
+    def build_in_process
+      Logger.info("    ..... building in process")
+      #TODO: configurable, what rake job if not exist
+      %x(bundle exec rake offshore:seed_schema --trace)
+      unless $? == 0
+        reset
+        raise "rake offshore:seed_schema failed!"
+      end
+      unlock
+    end
+    
+    def snapshot
+      Offshore::Snapshot::Template
+    end
+  end
+end

data/lib/offshore/server/errors.rb

@@ -0,0 +1,5 @@
+module Offshore
+  class CheckBackLater < StandardError
+    
+  end
+end

data/lib/offshore/server/logger.rb

@@ -0,0 +1,22 @@
+module Offshore
+  module Logger
+    extend self
+    
+    def say(type, message)
+      message = "[Offshore][#{type}][#{Time.now.to_i}][#{Time.now}] #{message}"
+      if defined?(Rails)
+        Rails.logger.send(type, message)
+      else
+        puts message
+      end
+    end
+    
+    def info(message)
+      say(:info, message)
+    end
+    
+    def error(message)
+      say(:error, message)
+    end
+  end
+end

data/lib/offshore/server/middleware.rb

@@ -0,0 +1,70 @@
+module Offshore
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+    
+    def init_server
+      Offshore::Database.init # has it's own singleton code
+    end
+    
+    def init_thread
+      return if @init_thread
+      @init_thread = true
+      
+      # TODO: move this to a config block
+      if defined?(Rails)
+        begin
+          require Rails.root.join("spec","spec_helper")
+        rescue
+          raise
+        end
+      end
+    end
+    
+    def init
+      init_thread
+      init_server
+    end
+
+
+    def call(env)
+      if (env["PATH_INFO"] =~ /^\/offshore_tests\/(.*)/) == 0
+        offshore_call($1, env)
+      else
+        @app.call(env)
+      end
+    end
+  
+    def offshore_call(method, env)
+      status = 500     
+      headers = {}
+      hash = {"error" => "Unknown method: #{method}"}
+      
+      Logger.info("Offshore Tests Action: #{method}")
+      
+      begin
+        case method
+        when "factory_create", "suite_start", "suite_stop", "test_start", "test_stop"
+          init if method == "suite_start"
+          controller = Controller.new(Rack::Request.new(env).params)
+          status, hash = controller.send(method)
+        end
+      rescue CheckBackLater => e
+        hash = {"error" => e.message}
+        status = Offshore::WAIT_CODE
+      rescue StandardError => e
+        hash = {"error" => e.message}
+        status = 500
+        raise # for now
+      end
+      
+      content = hash.to_json
+      headers['Content-Type'] = "application/json"
+      headers['Content-Length'] = content.length.to_s
+      out = [status, headers, [content]]
+      Logger.info("Offshore Tests #{method}... returns: #{out.to_s}")
+      out
+    end
+  end
+end

data/lib/offshore/server/mutex.rb

@@ -0,0 +1,154 @@
+# Adapted from... 
+# https://github.com/kenn/redis-mutex/blob/master/lib/redis/mutex.rb
+# https://github.com/kenn/redis-classy/blob/master/lib/redis/classy.rb
+
+module Offshore
+  #
+  # Options
+  #
+  # :block  => Specify in seconds how long you want to wait for the lock to be released. Speficy 0
+  #            if you need non-blocking sematics and return false immediately. (default: 1)
+  # :sleep  => Specify in seconds how long the polling interval should be when :block is given.
+  #            It is recommended that you do NOT go below 0.01. (default: 0.1)
+  # :expire => Specify in seconds when the lock should forcibly be removed when something went wrong
+  #            with the one who held the lock. (default: 10)
+  #
+  class Mutex
+    
+    DEFAULT_EXPIRE = 10*60*1000  # 10 minutes (I think)
+    LockError = Class.new(StandardError)
+    UnlockError = Class.new(StandardError)
+    AssertionError = Class.new(StandardError)
+    
+    attr_reader :key
+    def initialize(object, options={})
+      @key = (object.is_a?(String) || object.is_a?(Symbol) ? object.to_s : "#{object.class.name}:#{object.id}")
+      @block = options[:block] || 0   # defaults to not blocking (returns false)
+      @sleep = options[:sleep] || 0.1
+      @expire = options[:expire] || DEFAULT_EXPIRE
+    end
+    
+    # get, del, etc
+    def method_missing(command, *args, &block)
+      self.class.send(command, @key, *args, &block)
+    end
+
+    def lock
+      self.class.raise_assertion_error if block_given?
+      @locking = false
+
+      if @block > 0
+        # Blocking mode
+        start_at = Time.now
+        while Time.now - start_at < @block
+          @locking = true and break if try_lock
+          sleep @sleep
+        end
+      else
+        # Non-blocking mode
+        @locking = try_lock
+      end
+      @locking
+    end
+
+    def try_lock
+      now = Time.now.to_f
+      @expires_at = now + @expire                       # Extend in each blocking loop
+      return true   if setnx(@expires_at)               # Success, the lock has been acquired
+      return false  if get.to_f > now                   # Check if the lock is still effective
+
+      # The lock has expired but wasn't released... BAD!
+      return true   if getset(@expires_at).to_f <= now   # Success, we acquired the previously expired lock
+      return false  # Dammit, it seems that someone else was even faster than us to remove the expired lock!
+    end
+
+    def unlock(force = false)
+      # Since it's possible that the operations in the critical section took a long time,
+      # we can't just simply release the lock. The unlock method checks if expires_at
+      # is the one we though, and do not release when the lock timestamp was overwritten.
+
+      # FIXME TODO: bug here if this wasn't the one to lock it, but I don't have @expires_at in different threads, etc
+      force = true
+      if force
+        # Redis#del with a single key returns '1' or nil
+        !!del
+      else
+        false
+      end
+    end
+
+    def with_lock
+      if lock!
+        begin
+          @result = yield
+        ensure
+          unlock
+        end
+      end
+      @result
+    end
+
+    def lock!
+      lock or raise LockError, "failed to acquire lock #{key.inspect}"
+    end
+
+    def unlock!(force = false)
+      unlock(force) or raise UnlockError, "failed to release lock #{key.inspect}"
+    end
+
+    class << self
+      def db
+        Offshore.redis
+      end
+      
+      def method_missing(command, *args, &block)
+        db.send(command, *args, &block)
+      end
+            
+      def sweep
+        return 0 if (all_keys = keys).empty?
+
+        now = Time.now.to_f
+        values = mget(*all_keys)
+
+        expired_keys = all_keys.zip(values).select do |key, time|
+          time && time.to_f <= now
+        end
+
+        expired_keys.each do |key, _|
+          # Make extra sure that anyone haven't extended the lock
+          del(key) if getset(key, now + DEFAULT_EXPIRE).to_f <= now
+        end
+
+        expired_keys.size
+      end
+
+      def lock(object, options = {})
+        raise_assertion_error if block_given?
+        new(object, options).lock
+      end
+      
+      def unlock(object, options = {})
+        raise_assertion_error if block_given?
+        new(object, options).unlock
+      end
+
+      def lock!(object, options = {})
+        new(object, options).lock!
+      end
+      
+      def unlock!(object, options = {})
+        raise_assertion_error if block_given?
+        new(object, options).unlock!
+      end
+
+      def with_lock(object, options = {}, &block)
+        new(object, options).with_lock(&block)
+      end
+
+      def raise_assertion_error
+        raise AssertionError, 'block syntax has been removed from #lock, use #with_lock instead'
+      end
+    end
+  end
+end

data/lib/offshore/server/railtie.rb

@@ -0,0 +1,5 @@
+module Offshore
+  class Railtie < Rails::Railtie
+    config.app_middleware.use 'Offshore::Middleware'
+  end
+end

data/lib/offshore/server/redis.rb

@@ -0,0 +1,45 @@
+module Offshore
+  extend self
+  
+  # Accepts:
+  #   1. A 'hostname:port' String
+  #   2. A 'hostname:port:db' String (to select the Redis db)
+  #   3. A 'hostname:port/namespace' String (to set the Redis namespace)
+  #   4. A Redis URL String 'redis://host:port'
+  #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+  #      or `Redis::Namespace`.
+  def redis=(server)
+    case server
+    when String
+      if server =~ /redis\:\/\//
+        redis = Redis.connect(:url => server, :thread_safe => true)
+      else
+        server, namespace = server.split('/', 2)
+        host, port, db = server.split(':')
+        redis = Redis.new(:host => host, :port => port,
+          :thread_safe => true, :db => db)
+      end
+      namespace ||= default_namespace
+
+      @redis = Redis::Namespace.new(namespace, :redis => redis)
+    when Redis::Namespace
+      @redis = server
+    else
+      @redis = Redis::Namespace.new(default_namespace, :redis => server)
+    end
+  end
+
+  # Returns the current Redis connection. If none has been created, will
+  # create a new one from the Reqsue one (with a different namespace)
+  def redis
+    return @redis if @redis
+    self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
+    self.redis
+  end
+  
+  private
+  
+  def default_namespace
+    :offshore
+  end
+end

data/lib/offshore/server/snapshot.rb

@@ -0,0 +1,175 @@
+require 'erb'
+require 'digest/md5'
+require 'mysql2'
+
+module Offshore
+  module Snapshot
+    extend self
+    
+    def config
+      return @config if @config
+      
+      raise "Only supported in Rails for now" unless defined?(Rails)
+      
+      yml = Rails.root.join("config", "database.yml")
+      hash = YAML.load(ERB.new(File.read(yml)).result)["test"]
+
+      @config = {}
+      ['username', 'password', 'host', 'port', 'database', 'collation', 'charset'].each do |key|
+        if hash['master'] && hash['master'].has_key?(key)
+          @config[key] = hash['master'][key]
+        else
+          @config[key] = hash[key]
+        end
+      end
+      
+      @config
+    end
+  end
+end
+
+module Offshore
+  module Snapshot
+    module Template
+      extend self
+      
+      SNAPSHOT_KEY = "snapshot:checksum"
+      
+      def create
+        use_db(test_db)
+        use_db(template_db)
+        clone(test_db, template_db)
+        record_checksum(test_db)
+      end
+      
+      def rollback
+        use_db(test_db)
+        stored = Offshore.redis.get(SNAPSHOT_KEY)
+        sum = db_checksum(test_db)
+        
+        if stored == sum
+          Logger.info("   Snapshot checksum equal - not cloning")
+        else
+          Logger.info("   Snapshot checksum not equal - cloning")
+          use_db(template_db)
+          clone(template_db, test_db)
+          record_checksum(test_db) unless stored
+        end
+      end
+      
+      
+      def rollback2
+        use_db(test_db)
+        use_db(template_db)
+        if equal_checksum?(template_db, test_db)
+          Logger.info("   Snapshot checksum equal - not cloning")
+        else
+          Logger.info("   Snapshot checksum not equal - cloning")
+          clone(template_db, test_db)
+        end
+      end
+      
+      private
+      
+      def record_checksum(db)
+        sum = db_checksum(db)
+        Logger.info("    Snapshot checksum: #{sum}")
+        Offshore.redis.set(SNAPSHOT_KEY, sum)
+      end
+      
+      def equal_checksum?(from, to)
+        tem = db_checksum(from)
+        sum = db_checksum(to)
+        Logger.info("    Snapshot checksum (calculated) compare: #{sum}  ==  #{tem}")
+        tem == sum
+      end
+      
+      def test_db
+        @test_db ||= make_conn
+      end
+
+      def template_db
+        @template_db ||= make_conn("_offshore_template")
+      end
+
+      def clone(from, to)
+        empty_tables(to)
+        copy_tables(from, to)
+        copy_data(from, to)
+      end
+      
+      def db_checksum(db)
+        string = ""
+        name = current_db(db)
+        get_tables(db).each do |table|
+          row = db.query("CHECKSUM TABLE `#{name}`.`#{table}`")
+          string << ":"
+          string << row.first["Checksum"].to_s
+        end
+
+        Digest::MD5.hexdigest(string)
+      end
+      
+      def make_conn(append="")
+        ar = Offshore::Snapshot.config
+        config = {}
+        config['reconnect'] = true
+        config['flags'] = Mysql2::Client::MULTI_STATEMENTS
+        
+        ['username', 'password', 'host', 'port'].each do |key|
+          config[key.to_sym] = ar[key]
+        end
+        
+        client = Mysql2::Client.new(config)
+        client.instance_variable_set("@offshore_db_name", "#{ar['database']}#{append}")
+        client
+      end
+
+      def use_db(db)
+        original_db = current_db(db)
+        begin
+          db.query("create database `#{original_db}` DEFAULT CHARACTER SET `utf8`") # TODO forcing UTF8
+        rescue
+        end
+        db.query("use `#{original_db}`")
+      end
+
+      def empty_tables(db)
+        name = current_db(db)
+        get_tables(db).each do |table|
+          db.query("drop table if exists `#{name}`.`#{table}`")
+        end
+      end
+      
+      def copy_tables(from, to)
+        from_db = current_db(from)
+        to_db = current_db(to)
+        get_tables(from).each do |table|
+          to.query("create table `#{to_db}`.`#{table}` like `#{from_db}`.`#{table}`")
+        end
+      end
+
+      def copy_data(from, to)
+        from_db = current_db(from)
+        to_db = current_db(to)
+        get_tables(from).each do |table|
+          to.query("insert into `#{to_db}`.`#{table}` select * from `#{from_db}`.`#{table}`")
+        end
+      end
+
+      def current_db(db)
+        db.instance_variable_get("@offshore_db_name")
+        # db.query("select database()").first.values[0]
+      end
+
+      def get_tables(db)
+        table_array = []
+        db.query("show tables").each do |row|
+          table_array << row.values[0]
+        end
+        table_array
+      end
+      
+    end
+  end
+end

data/lib/offshore/server.rb

@@ -0,0 +1,10 @@
+require "redis"
+require "offshore/server/errors"
+require "offshore/server/logger"
+require "offshore/server/redis"
+require "offshore/server/mutex"
+require "offshore/server/snapshot"
+require "offshore/server/database"
+require "offshore/server/controller"
+require "offshore/server/middleware"
+require "offshore/server/railtie" if defined?(Rails)

data/lib/offshore/tasks.rb

@@ -0,0 +1,35 @@
+namespace :offshore do
+  task :setup
+  task :seed
+  
+  task :preload do
+    require "offshore"
+  end
+  
+  task :schema_snapshot => [:preload, :setup] do
+    Offshore::Database.schema_snapshot
+  end
+  
+  task :schema_rollback => [:preload, :setup] do
+    Offshore::Database.snapshoter.rollback
+  end
+  
+  task :unlock => [:preload, :setup] do
+    Offshore::Database.unlock
+  end
+  
+  task :shutdown => [:preload, :setup] do
+    Offshore::Database.shutdown
+  end
+  
+  task :startup => [:preload, :setup] do
+    Offshore::Database.startup(false)
+  end
+  
+  task :reset => [:preload, :setup] do
+    Offshore::Database.reset
+  end
+  
+  task :seed_schema => [ :preload, :setup, :seed, :schema_snapshot ]
+  
+end

data/lib/offshore/version.rb

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

data/lib/offshore.rb

@@ -0,0 +1,29 @@
+require "offshore/version"
+
+module Offshore
+  extend self
+  
+  WAIT_CODE = 499
+  
+  def suite
+    @suite ||= Suite.new
+  end
+  
+  def test
+    if @test && @test.run?
+      # run again because it crashed in execution
+      @test.failed
+    end
+    @test ||= Test.new
+  end
+  
+  protected
+    
+  def internal_test_ended
+    # called from test.failed and test.stop
+    @test = nil
+  end
+end
+
+require "offshore/client"
+require "offshore/server"

data/offshore.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/offshore/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Brian Leonard"]
+  gem.email         = ["brian@bleonard.com"]
+  gem.description   = %q{For handling remote factories and tests}
+  gem.summary       = %q{For handling remote factories and tests}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "offshore"
+  gem.require_paths = ["lib"]
+  gem.version       = Offshore::VERSION
+  
+  gem.add_dependency "multi_json"
+  gem.add_dependency "faraday"
+  gem.add_dependency "redis"
+  gem.add_dependency "redis-namespace"
+  gem.add_dependency "mysql2"
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: offshore
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brian Leonard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: For handling remote factories and tests
+email:
+- brian@bleonard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/offshore.rb
+- lib/offshore/client.rb
+- lib/offshore/client/factory_offshore.rb
+- lib/offshore/client/host.rb
+- lib/offshore/client/suite.rb
+- lib/offshore/client/test.rb
+- lib/offshore/server.rb
+- lib/offshore/server/controller.rb
+- lib/offshore/server/database.rb
+- lib/offshore/server/errors.rb
+- lib/offshore/server/logger.rb
+- lib/offshore/server/middleware.rb
+- lib/offshore/server/mutex.rb
+- lib/offshore/server/railtie.rb
+- lib/offshore/server/redis.rb
+- lib/offshore/server/snapshot.rb
+- lib/offshore/tasks.rb
+- lib/offshore/version.rb
+- offshore.gemspec
+homepage: ''
+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.24
+signing_key: 
+specification_version: 3
+summary: For handling remote factories and tests
+test_files: []