mysqlnoio 0.1.0

data/Rakefile

@@ -0,0 +1,43 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'mysqlnoio'
+
+desc "Builds the gem"
+task :build do
+  sh "gem build mysqlnoio.gemspec"
+end
+
+desc "Publishes the gem to fury.io"
+task :publish => [:build] do |t|
+  sh "git tag -f #{MySQLNoIo::VERSION}"
+  sh "git push origin #{MySQLNoIo::VERSION} -f"
+  sh "curl -F p1=@mysqlnoio-#{MySQLNoIo::VERSION}.gem https://push.fury.io/BEz67VknqnyqmV6p7Huq/"
+end
+
+desc "Cleans the project directory up"
+task :clean do
+  sh "rm -rf doc/ tmp/"
+  sh "rm -f mysqlnoio-*.gem"
+end
+
+# Various RSpec Bitties
+base_opts = '--color --order random'
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+  t.rspec_opts = "#{base_opts} --tag ~integration"
+end
+
+desc "Run integration specs"
+RSpec::Core::RakeTask.new(:integration) do |t|
+  t.verbose = false
+  t.rspec_opts = "#{base_opts} --tag integration"
+end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.verbose = false
+  t.rspec_opts = base_opts
+end
+
+task :default => :spec

data/Vagrantfile

@@ -0,0 +1,18 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+$boot = <<SCRIPT
+sudo apt-get install build-essential
+
+curl -L https://get.rvm.io | bash -s --autolibs=3 --ruby
+SCRIPT
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "ubuntu-12.04.2-server-adm54-vmware-fusion"
+  config.vm.box_url = "https://s3.amazonaws.com/gsc-vagrant-boxes/ubuntu-12.04.2-server-amd64.box"
+
+  config.vm.provision :shell do |shell|
+    shell.inline = $script
+    shell.path = 'vagrant/provision.sh'
+  end
+end

data/bin/mysql-noio

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'mysqlnoio'
+
+credentials = {}
+wraps = []
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: mysql-noio [options] <command>"
+
+  # Determine the MySQL connection parameters
+  opts.on("-u", "--user USER", "MySQL Username") do |v|
+    credentials[:username] = v
+  end
+
+  opts.on("-p", "--password PASSWORD", "MySQL Password") do |v|
+    credentials[:password] = v
+  end
+
+  opts.on("-h", "--host HOST", "MySQL Server Host") do |v|
+    credentials[:host] = v
+  end
+
+
+  opts.on("-t", "--lock-tables", "Lock tables with a read lock") do |v|
+    wraps << :lock
+  end
+
+  opts.on("-s", "--stop-slave", "Stop the slave thread") do |v|
+    wraps << :stop
+  end
+
+  opts.on
+end.parse!
+
+client = Mysql2::Client.new(credentials)
+
+stack = MySQLNoIo::WrapStack.new
+stack.add_wrap MySQLNoIo::Wraps::DeactivatedSlave.new client if wraps.include? :stop
+stack.add_wrap MySQLNoIo::Wraps::GlobalLock.new client if wraps.include? :lock
+
+stack.execute do
+  spawn *ARGV
+  Process.wait
+end
+
+exit $?.to_i
+

data/lib/mysqlnoio/about.rb

@@ -0,0 +1,12 @@
+
+module MySQLNoIo
+  # Used in Gemspec and Commander
+  NAME = 'mysqlnoio'
+
+  # Used in Gemspec and Commander
+  VERSION = '0.1.0'
+
+  # Used in Gemspec and Commander
+  DESCRIPTION = 'mysqlnoio allows you to execute commands while MySQL is locked.'
+end
+

data/lib/mysqlnoio/errors.rb

@@ -0,0 +1,11 @@
+
+module MySQLNoIo
+  # A collection of erros which MySQLNoIo might raise.
+  module Errors
+
+    # represents an argument passed in to a method is invalid.
+    class ArgumentError < ::ArgumentError
+    end
+  end
+end
+

data/lib/mysqlnoio/wrap.rb

@@ -0,0 +1,34 @@
+
+module MySQLNoIo
+
+  # A wrap represents a open/close block which always runs a before and an
+  # after statement.
+  #
+  # Passing a block to #execute will execute the block from between the
+  # statements.
+  #
+  # Example:
+  #  class FooWrap
+  #    def execute &block
+  #      puts "Hi"
+  #
+  #      yeild(block)
+  #    ensure
+  #      puts "Bye"
+  #    end
+  #  end
+  #
+  #  foo = FooWrap.new()
+  #  foo.execute do
+  #    puts "Ahh! Safety!"
+  #  end
+  #
+  # Will output:
+  # Hi
+  # Ahh! Safety!
+  # Bye
+  #
+  class Wrap
+  end
+end
+

data/lib/mysqlnoio/wrap_stack.rb

@@ -0,0 +1,65 @@
+
+module MySQLNoIo
+  # A WrapStack collects a series of Wraps, and runs their #execute commands
+  # inside one another.
+  #
+  # Example:
+  #  stack = MySQLNoIo::WrapStack.new()a
+  #
+  #  wrapFoo = Wrap::Foo.new()
+  #  wrapBar = Wrap::Bar.new()
+  #
+  #  stack.add_stack wrapFoo
+  #  stack.add_stack wrapBar
+  #  stack.execute do
+  #    puts "hi"
+  #  end
+  #
+  #  Is identical to:
+  #  wrapFoo.execute do
+  #    wrapBar.execute do
+  #      puts "hi"
+  #    end
+  #  end
+  #
+  class WrapStack
+    def initialize
+      @wraps = []
+    end
+
+    # Add a layer to wrap around the execution of the command
+    #
+    # @param [MySQLNoIo::Wrap] the wrapper to add to the stack
+    # @raise [MySQLNoIo::Errors::ArgumentError] if the wrapper is not sufficient
+    #
+    # @return [TrueClass]
+    def add_wrap wrap
+      unless wrap.respond_to?('execute')
+        raise MySQLNoIo::Errors::ArgumentError.new('Wrap must respond to #execute and accept a block.')
+      end
+
+      @wraps << wrap
+
+      true
+    end
+
+    # Execute your bit of code from within the safety and comfort of the
+    # wrappers appended to the stack.
+    def execute &block
+      # Brace yourself.
+      #
+      # This next bit of code creates a nested lamda like the WrapStack
+      # describes.
+      deep_proc = @wraps.reverse.inject(block) do |deep_proc, layer|
+        Proc.new do
+          layer.execute do
+            deep_proc.call
+          end
+        end
+      end
+
+      deep_proc.call
+    end
+  end
+end
+

data/lib/mysqlnoio/wraps/blocks.rb

@@ -0,0 +1,24 @@
+module MySQLNoIo
+  module Wraps
+    # Just an example Wrap for testing and examples.
+    class Blocks
+      # The before block will be run prior to the execution.
+      def before &block
+        @prior = block
+      end
+
+      # The after block will be run post execution.
+      def after &block
+        @post = block
+      end
+
+      # Call the prior block, then execute, and then call the post-block.
+      def execute &block
+        @prior.call if @prior.respond_to?(:call)
+        block.call
+      ensure
+        @post.call if @post.respond_to?(:call)
+      end
+    end
+  end
+end

data/lib/mysqlnoio/wraps/deactivated_slave.rb

@@ -0,0 +1,18 @@
+module MySQLNoIo
+  module Wraps
+    # Stops the database slave entirely for your command
+    class DeactivatedSlave
+      def initialize mysql
+        @mysql = mysql
+      end
+
+      def execute &block
+        @mysql.query('STOP SLAVE;')
+        yield
+      ensure
+        @mysql.query('START SLAVE;')
+      end
+    end
+  end
+end
+

data/lib/mysqlnoio/wraps/global_lock.rb

@@ -0,0 +1,21 @@
+module MySQLNoIo
+  module Wraps
+    # Allows you to run commands against a MySQL database, while MySQL's
+    # tables are locked, and the tables are flushed.
+    class GlobalLock
+      # Prepare to set up the GlobalLock wrapper, with the mysql2 connection
+      def initialize mysql
+        @mysql = mysql
+      end
+
+      # Lock the tables, run our command, and then unlock the tables.
+      def execute &block
+        @mysql.query("FLUSH TABLES WITH READ LOCK;")
+        yield
+      ensure
+        @mysql.query("UNLOCK TABLES;")
+      end
+    end
+  end
+end
+

data/lib/mysqlnoio.rb

@@ -0,0 +1,19 @@
+
+require 'mysql2'
+
+require 'mysqlnoio/about'
+
+require 'mysqlnoio/errors'
+
+require 'mysqlnoio/wrap_stack'
+require 'mysqlnoio/wrap'
+require 'mysqlnoio/wraps/blocks'
+require 'mysqlnoio/wraps/global_lock'
+require 'mysqlnoio/wraps/deactivated_slave'
+
+
+# See: README.md
+module MySQLNoIo
+
+end
+

data/mysqlnoio.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'mysqlnoio/about'
+
+Gem::Specification.new do |gem|
+  gem.name          = MySQLNoIo::NAME
+  gem.version       = MySQLNoIo::VERSION
+  gem.description   = MySQLNoIo::DESCRIPTION
+  gem.summary       = 'Execute shell commands while MySQL IO is stopped.'
+  gem.homepage      = 'https://zippykid.com'
+  gem.authors       = ["ZippyKid", "Graham Christensen"]
+  gem.email         = ["info@zippykid.com"]
+  gem.licenses      = ["MIT"]
+
+  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.require_paths = ["lib"]
+
+  gem.add_dependency('mysql2')
+
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('debugger')
+
+  # Guard:
+  gem.add_development_dependency('guard')
+  gem.add_development_dependency('guard-rspec')
+  gem.add_development_dependency('guard-shell')
+  gem.add_development_dependency('rb-fsevent', '~> 0.9')
+  gem.add_development_dependency('rb-inotify', '~> 0.9')
+  gem.add_development_dependency('travis-lint')
+
+  # Docs
+  gem.add_development_dependency('yard')
+  gem.add_development_dependency('redcarpet')
+end
+

data/spec/integration/mysql-noio_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper.rb'
+
+describe "mysql-noio", :integration => true do
+  context "called with no parameters" do
+    let (:output) { `bundle exec #{project_root}/bin/mysql-noio 2>&1` }
+
+    it "exits with a zero error code" do
+      $?.to_i.should eq(0)
+    end
+
+    it "does not contain something that looks like a stack trace" do
+      output.should_not =~ /in `<main>'/
+      output.should_not =~ /syntax error/
+    end
+  end
+end
+

data/spec/mysqlnoio/wrap_stack_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe MySQLNoIo::WrapStack do
+  let(:stack) { MySQLNoIo::WrapStack.new }
+  describe "#add_wrap" do
+
+    context "An invalid wrap is provided" do
+      it "expects the method to have an #execute method" do
+        expect {
+          stack.add_wrap(nil)
+        }.to raise_error(MySQLNoIo::Errors::ArgumentError, /\#execute/)
+      end
+    end
+
+    context "A valid wrap is provided" do
+      let (:wrap) { double("MySQLNoIo::Wrap", execute: true) }
+      it "only requires the #execute method to be callable" do
+        stack.add_wrap(wrap).should eq(true)
+      end
+    end
+  end
+
+  describe "#execute" do
+    let (:wrap_foo) do
+      wrap = MySQLNoIo::Wraps::Blocks.new
+      wrap.before do
+        @output << "foo-before\n"
+      end
+      wrap.after do
+        @output << "foo-after\n"
+      end
+
+      wrap
+    end
+
+    let (:wrap_bar) do
+      wrap = MySQLNoIo::Wraps::Blocks.new
+      wrap.before do
+        @output << "bar-before\n"
+      end
+      wrap.after do
+        @output << "bar-after\n"
+      end
+
+      wrap
+    end
+
+    it "Calls the wrappers in order, and then my bits." do
+      @output = ""
+      stack.add_wrap wrap_foo
+      stack.add_wrap wrap_bar
+      stack.execute do
+        @output << "Cheesy filling!\n"
+      end
+
+      desired_output = "foo-before\n"
+      desired_output << "bar-before\n"
+      desired_output << "Cheesy filling!\n"
+      desired_output << "bar-after\n"
+      desired_output << "foo-after\n"
+
+      @output.should eq(desired_output)
+    end
+  end
+end
+

data/spec/mysqlnoio/wraps/blocks_spec.rb

@@ -0,0 +1,44 @@
+
+describe MySQLNoIo::Wraps::Blocks do
+  subject { MySQLNoIo::Wraps::Blocks.new() }
+  context "accepts a before block" do
+    it { should respond_to :before }
+  end
+
+  context "accepts an after block" do
+    it { should respond_to :after }
+  end
+
+  describe "#execute" do
+    context "executing a block" do
+      let (:wrapper) { MySQLNoIo::Wraps::Blocks.new() }
+      let (:block_before) { Proc.new do @output << "chocolate" end }
+      let (:block_execute) { Proc.new do @output << "icing" end }
+      let (:block_after) { Proc.new do @output << "vanilla" end }
+
+      it "executes the block passed to #execute" do
+        @output = ""
+        wrapper.execute do block_execute.call end
+
+        @output.should eq("icing")
+      end
+
+      it "executes the before block ... before" do
+        @output = ""
+        wrapper.before do block_before.call end
+        wrapper.execute do block_execute.call end
+
+        @output.should eq("chocolateicing")
+      end
+
+      it "executes the after block ... after" do
+        @output = ""
+        wrapper.after do block_after.call end
+        wrapper.execute do block_execute.call end
+
+        @output.should eq("icingvanilla")
+      end
+    end
+  end
+end
+

data/spec/mysqlnoio/wraps/deactivated_slave_spec.rb

@@ -0,0 +1,25 @@
+describe MySQLNoIo::Wraps::DeactivatedSlave do
+  describe "#execute" do
+    it "Runs STOP SLAVE and START SLAVE around our command" do
+      @cmds = ""
+
+      mysql = double("MySQL2::Client")
+      mysql.should_receive(:query).exactly(2).times do |arg|
+        @cmds << "#{arg}\n"
+      end
+
+      wrap = MySQLNoIo::Wraps::DeactivatedSlave.new mysql
+      wrap.execute do
+        @cmds << "-- my command\n"
+      end
+
+      @cmds.should eq(<<-FOO
+STOP SLAVE;
+-- my command
+START SLAVE;
+FOO
+)
+    end
+  end
+end
+

data/spec/mysqlnoio/wraps/global_lock_spec.rb

@@ -0,0 +1,25 @@
+describe MySQLNoIo::Wraps::GlobalLock do
+  describe "#execute" do
+    it "Runs lock and unlock around our command" do
+      @cmds = ""
+
+      mysql = double("MySQL2::Client")
+      mysql.should_receive(:query).exactly(2).times do |arg|
+        @cmds << "#{arg}\n"
+      end
+
+      wrap = MySQLNoIo::Wraps::GlobalLock.new mysql
+      wrap.execute do
+        @cmds << "-- my command\n"
+      end
+
+      @cmds.should eq(<<-FOO
+FLUSH TABLES WITH READ LOCK;
+-- my command
+UNLOCK TABLES;
+FOO
+)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'mysqlnoio'
+
+def project_root
+  File.realpath(File.dirname(__FILE__) + "/../")
+end
+

data/vagrant/provision.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+apt-get update
+apt-get --yes install libmysqlclient-dev mysql-server-5.5
+
+curl -L https://get.rvm.io | bash -s stable --autolibs=3 --ruby
+source /usr/local/rvm/scripts/rvm
+rvm in /vagrant do bundle install
+
+cd /vagrant
+
+rake
+