php_fpm_docker 0.0.1

data/lib/php_fpm_docker/version.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+# VERSION SPEC
+module PhpFpmDocker
+  VERSION = '0.0.1'
+end

data/php_fpm_docker.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'php_fpm_docker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'php_fpm_docker'
+  spec.version       = PhpFpmDocker::VERSION
+  spec.authors       = ['Christian Simon']
+  spec.email         = ['simon@swine.de']
+  spec.description   = 'Use docker containers for PHP from FPM config'
+  spec.summary       = 'Use docker containers for PHP from FPM config'
+  spec.homepage      = 'https://github.com/simonswine/php_fpm_docker'
+  spec.license       = 'GPLv3'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'docker-api'
+  spec.add_dependency 'inifile'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'coveralls'
+
+end

data/spec/helper.rb

@@ -0,0 +1,19 @@
+module Helper
+  def inst_set(var, value)
+    if value.nil?
+      value=nil
+    else
+      value=Marshal.load( Marshal.dump(value))
+    end
+    a_i.instance_variable_set(var, value)
+  end
+
+  def inst_get(var)
+    a_i.instance_variable_get(var)
+  end
+
+  def method(*args)
+    func = self.class.description[1..-1].to_sym
+    a_i.instance_exec(func) {|f| send(f,*args)}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'coveralls'
+require 'helper'
+
+Coveralls.wear!
+
+# Set load path for this module
+dir = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+$LOAD_PATH.unshift File.join(dir, 'lib')
+
+RSpec.configure do |config|
+  config.include Helper
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.order = :random
+end

data/spec/unit/application_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'php_fpm_docker/application'
+
+describe PhpFpmDocker::Application do
+  before(:example) {
+    @dbl_logger_instance = double
+    @dbl_logger = class_double('Logger').as_stubbed_const()
+    allow(@dbl_logger).to receive(:new).and_return(@dbl_logger_instance)
+
+    @dbl_fileutils = class_double('FileUtils').as_stubbed_const()
+    allow(@dbl_fileutils).to receive(:mkdir_p)
+  }
+
+  let (:a_i){
+    described_class.new
+  }
+  let (:a_c){
+    described_class
+  }
+  let (:pid_default) {
+    1234
+  }
+
+  describe '#initialize' do
+    it "not raise error" do
+      expect{a_i}.not_to raise_error
+    end
+  end
+  describe '#help' do
+    let (:method) {
+      a_i.instance_eval{ help }
+    }
+    it "return help" do
+      expect(a_i).to receive(:allowed_methods).and_return([:valid])
+      expect{method}.to output(/valid/).to_stderr
+    end
+  end
+  describe '#run' do
+    let (:method) {
+      a_i.instance_eval{ run }
+    }
+    before (:example) do
+      a_i.instance_variable_set(:@php_name,'php_name')
+      @argv = []
+      stub_const('ARGV', @argv)
+    end
+    it "correct arguments" do
+      expect(a_i).to receive(:parse_arguments).with(@argv).and_return(:valid)
+      expect(a_i).to receive(:send).with(:valid).and_return(123)
+      expect(a_i).to receive(:exit).with(123)
+      expect{method}.not_to raise_error
+    end
+    it "incorrect arguments" do
+      allow(@dbl_logger_instance).to receive(:warn).with('php_name')
+      expect(a_i).to receive(:parse_arguments).with(@argv).and_raise(RuntimeError, 'wrong')
+      expect(a_i).to receive(:help)
+      expect(a_i).to receive(:exit).with(3)
+      expect{method}.not_to raise_error
+    end
+  end
+  describe '#parse_arguments' do
+    let (:method) {
+      a_i.instance_exec(@args) {|x| parse_arguments(x)}
+    }
+    let (:valid_args) {
+      a_i.instance_variable_set(:@php_name,'php_name')
+      expect(a_i).to receive(:allowed_methods).and_return([:valid])
+    }
+    it 'fails without arguments' do
+      @args = []
+      expect{method}.to raise_error(/no argument/)
+    end
+    it "args=['install']" do
+      @args = ['install']
+      expect(method).to eq(:install)
+    end
+    it "args=['name','valid']" do
+      valid_args
+      @args = ['name','valid']
+      expect(@dbl_logger_instance).to receive(:info)
+      expect(method).to eq(:valid)
+      expect(a_i.instance_variable_get(:@php_name)).to eq('name')
+    end
+    it "args=['name','invalid']" do
+      valid_args
+      @args = ['name','invalid']
+      expect{method}.to raise_error(/unknown method/)
+    end
+    it "args=['name']" do
+      @args = ['name']
+      expect{method}.to raise_error(/wrong argument count/)
+    end
+  end
+  describe '#allowed_methods' do
+    let (:method) {
+      a_i.instance_eval{ allowed_methods }
+    }
+    [:start, :stop, :reload, :restart, :status].each do |cmd|
+      it "have command #{cmd}" do
+        expect(method).to include(cmd)
+      end
+    end
+    [:run, :install].each do |cmd|
+      it "have no command #{cmd}" do
+        expect(method).not_to include(cmd)
+      end
+    end
+  end
+  describe '#pid' do
+    let (:method) {
+      a_i.instance_eval{ pid }
+    }
+    let (:file) {
+      Tempfile.new('foo')
+    }
+    it 'return pid from file if exists and int' do
+      file.write(pid_default.to_s)
+      file.flush
+      allow(a_i).to receive(:pid_file).and_return(file.path)
+      expect(method).to eq(pid_default)
+    end
+    it 'return nil without pid file' do
+      allow(a_i).to receive(:pid_file).and_return('/tmp/not/existing')
+      expect(method).to eq(nil)
+    end
+    it 'return nil pid from file if exists and no int' do
+      file.write("fuckyeah!")
+      file.flush
+      allow(a_i).to receive(:pid_file).and_return(file.path)
+      expect(method).to eq(nil)
+    end
+  end
+  describe '#pid=' do
+    before(:example) do
+      @file=Tempfile.new('foo')
+      @file.write(1234)
+      @file.flush
+    end
+    context 'argument pid is 456' do
+      let (:method) {
+        a_i.instance_exec(nil) {|x| self.pid=456 }
+      }
+      after(:example) do
+        allow(a_i).to receive(:pid_file).and_return(@file.path)
+        method
+        expect(open(@file.path).read.strip.to_i).to eq(456)
+      end
+      it 'pid file exists before' do
+      end
+      it 'pid file not existing' do
+        File.unlink @file.path
+      end
+    end
+    context 'argument pid is nil' do
+      let (:method) {
+        a_i.instance_exec(nil) {|x| self.pid=x }
+      }
+      it 'pid file will removed if exists' do
+        allow(a_i).to receive(:pid_file).and_return(@file.path)
+        method
+        expect(File.exist?(@file.path)).to eq(false)
+      end
+      it 'pid file not existing' do
+        path = @file.path
+        @file.delete
+        expect(@dbl_logger_instance).to receive(:debug).with(/No pid file found/)
+        allow(a_i).to receive(:pid_file).and_return(path)
+        method
+      end
+    end
+  end
+  describe '#running?' do
+    let (:method) {
+      a_i.instance_eval{ running? }
+    }
+    it 'return false if no pid' do
+      expect(a_i).to receive(:pid).and_return(nil)
+      expect(method).to be(false)
+    end
+    it 'return true if pid exists' do
+      pid = 1234
+      allow(a_i).to receive(:pid).and_return(pid)
+      # mock process
+      dbl_process = class_double('Process').as_stubbed_const()
+      allow(dbl_process).to receive(:getpgid).with(pid)
+      expect(method).to be(true)
+    end
+    it 'return false for non existing pid' do
+      pid = 1234
+      allow(a_i).to receive(:pid).and_return(pid)
+      # mock process
+      dbl_process = class_double('Process').as_stubbed_const()
+      allow(dbl_process).to receive(:getpgid).and_raise(Errno::ESRCH)
+      expect(method).to be(false)
+    end
+  end
+end

data/spec/unit/launcher_spec.rb

@@ -0,0 +1,339 @@
+require 'spec_helper'
+require 'php_fpm_docker/launcher'
+
+describe PhpFpmDocker::Launcher do
+  before(:example) {
+    # Logger
+    @dbl_logger_instance = double
+    [:debug,:error,:warn,:info,:fatal].each do |loglevel|
+      allow(@dbl_logger_instance).to receive(loglevel)
+    end
+    @dbl_logger = class_double('Logger').as_stubbed_const()
+    allow(@dbl_logger).to receive(:new).and_return(@dbl_logger_instance)
+
+    @dbl_pool = class_double('PhpFpmDocker::Pool').as_stubbed_const()
+
+    # Fileutils
+    @dbl_fileutils = class_double('FileUtils').as_stubbed_const()
+    allow(@dbl_fileutils).to receive(:mkdir_p)
+  }
+  let (:a_i){
+    allow_any_instance_of(described_class).to receive(:test)
+    described_class.new(@name ||=  'launcher1')
+  }
+  let (:a_c){
+    described_class
+  }
+  describe '#initialize' do
+    let (:method){
+      expect_any_instance_of(described_class).to receive(:test)
+      described_class.new(@name ||=  'launcher1')
+    }
+    it 'should not raise error' do
+      expect{method}.not_to raise_error
+    end
+  end
+  describe '#test' do
+    before(:example) {
+      expect_any_instance_of(described_class).to receive(:test).and_call_original
+      @downstream_methods = [:test_docker_image,:test_directories, :parse_config]
+    }
+    let (:method){
+      described_class.new(@name ||=  'launcher1')
+    }
+    it 'should call down stream functions' do
+      @downstream_methods.each do |m|
+        expect_any_instance_of(described_class).to receive(m)
+      end
+      method
+    end
+    it 'should exit on runtime errors' do
+      @downstream_methods.each do |m|
+        allow_any_instance_of(described_class).to receive(m).and_raise(RuntimeError,"error")
+      end
+      expect_any_instance_of(described_class).to receive(:exit).with(1)
+      method
+    end
+  end
+  describe '#run' do
+    before (:example) {
+      @pid = 12345
+      allow(a_i).to receive(:start_pools)
+      allow(a_i).to receive(:fork).and_return(@pid)
+    }
+    it 'should start pools' do
+      # start pools
+      expect(a_i).to receive(:start_pools)
+      method
+    end
+    it 'should fork and detach daemon' do
+      expect(a_i).to receive(:fork).once do |&block|
+        expect(a_i).to receive(:fork_run).once
+        block.call
+      end.and_return(@pid)
+      expect(Process).to receive(:detach).with(@pid)
+      method
+    end
+    it 'shoud return pid' do
+      expect(method).to eq(@pid)
+    end
+  end
+  describe '#fork_run' do
+    before (:example) {
+      allow(Signal).to receive(:trap)
+      allow(Kernel).to receive(:loop)
+    }
+    it 'should handle signal USR1' do
+      expect(Signal).to receive(:trap).with('USR1').once do |&block|
+        expect(a_i).to receive(:reload_pools)
+        block.call
+      end
+      method
+    end
+    it 'should handle signal TERM' do
+      expect(Signal).to receive(:trap).with('TERM').once do |&block|
+        expect(a_i).to receive(:stop_pools)
+        expect(a_i).to receive(:exit).with(0)
+        block.call
+      end
+      method
+    end
+    it 'should loop and check pools' do
+      expect(Kernel).to receive(:loop) do |&block|
+        expect(a_i).to receive(:sleep).with(1)
+        expect(a_i).to receive(:check_pools)
+        block.call
+      end
+      method
+    end
+  end
+  describe '#check_pools'
+  describe '#start_pools' do
+    before (:example) {
+      allow(a_i).to receive(:reload_pools)
+    }
+    it 'should reset @pools' do
+      a_i.instance_variable_set(:@pools, {:lala => :test})
+      method
+      expect(a_i.instance_variable_get(:@pools)).to eq({})
+    end
+    it 'should trigger reload pools' do
+      expect(a_i).to receive(:reload_pools)
+      method
+    end
+  end
+  describe '#stop_pools' do
+    before (:example) {
+      allow(a_i).to receive(:reload_pools)
+    }
+    it 'should trigger reload pools' do
+      expect(a_i).to receive(:reload_pools)
+      method
+    end
+  end
+  describe '#create_missing_pool_objects' do
+    let (:set) {
+      inst_set(:@pools,@pools)
+      inst_set(:@pools_old,@pools_old)
+    }
+    let (:compare) {
+      expect(inst_get(:@pools)).to match(@pools)
+      expect(inst_get(:@pools_old)).to match(@pools_old)
+    }
+    let (:method1) {
+      set
+      method
+      compare
+    }
+    it 'should not fail with nil values' do
+      @pools = nil
+      @pools_old = nil
+      method1
+    end
+    it 'should not fail with empty hashes' do
+      @pools = {}
+      @pools_old = {}
+      method1
+    end
+    it 'should copy objects correctly' do
+      @pools = { :hash1 => {}, :hash3 => {}}
+      @pools_old = {
+        :hash1 => {:object => :object1},
+        :hash2 => {:object => :object2},
+        :hash3 => {:object => :object3}
+      }
+      set
+      method
+      @pools = {
+        :hash1 => {:object => :object1},
+        :hash3 => {:object => :object3}
+      }
+      compare
+    end
+  end
+  describe '#move_existing_pool_objects' do
+    let (:set) {
+      inst_set(:@pools,@pools)
+    }
+    let (:compare) {
+      expect(a_i.instance_variable_get(:@pools)).to match(@result)
+    }
+    let (:set_method_compare) {
+      set
+      method
+      compare
+    }
+    before(:example) {
+      allow(@dbl_pool).to receive(:new).and_return(:object)
+    }
+    it 'should not fail with nil value' do
+      @pools = nil
+      @result = nil
+      set_method_compare
+    end
+    it 'should not fail with empty hash' do
+      @pools = {}
+      @result = {}
+      set_method_compare
+    end
+    it 'should create missing objects' do
+      @pools = {
+        :hash1 => {:object => :object1},
+        :hash2 => {:name => :name2, :config => :config2},
+        :hash3 => {:object => :object3}
+      }
+      expect(@dbl_pool).to receive(:new) do |args|
+        expect(args).to have_key(:launcher)
+        expect(args).to include(@pools[:hash2])
+      end.and_return(:object2)
+      set
+      method
+      @result = @pools
+      @result[:hash2][:object] = :object2
+      compare
+    end
+    it 'should not recreate existing objects' do
+      @result = @pools = {
+        :hash1 => {:object => :object1},
+        :hash2 => {:object => :object2},
+      }
+      expect(@dbl_pool).not_to receive(:new)
+      set_method_compare
+    end
+  end
+  describe '#reload_pools' do
+    before(:example) {
+      [
+        :move_existing_pool_objects,
+        :pools_action,
+        :create_missing_pool_objects,
+      ].each {|m| allow(a_i).to receive(m)}
+      allow(a_i).to receive(:pools_from_config).and_return({})
+      inst_set(:@pools, {})
+      inst_set(:@pools_old, {})
+    }
+    let(:check_set_op){
+      expect(a_i).to receive(:pools_action) do |p,p_h,action|
+        next if action != @method
+
+        source = {
+          :stop  => :@pools_old,
+          :start => :@pools,
+        }
+        expect(p).to be(inst_get(source[@method]))
+        expect(p_h).to eq(@result)
+
+      end.at_least(:once)
+      inst_set(:@pools, {
+        :hash1 => {:object => :object1},
+        :hash2 => {:object => :object2},
+      })
+      method({
+        :hash1 => {:object => :object1},
+        :hash3 => {:object => :object3},
+        :hash4 => {:object => :object4},
+      })
+    }
+    it 'should read pool from config with arg=nil' do
+      test = {:me => :myself}
+      expect(a_i).to receive(:pools_from_config).once.and_return(test)
+      method
+      expect(inst_get(:@pools)).to eq(test)
+    end
+    it 'should read pool from args' do
+      test = {:me => :myself}
+      method(test)
+      expect(inst_get(:@pools)).to eq(test)
+    end
+    it 'should call :create_missing_pool_objects' do
+      expect(a_i).to receive(:create_missing_pool_objects).once
+      method
+    end
+    it 'should call :move_existing_pool_objects' do
+      expect(a_i).to receive(:move_existing_pool_objects).once
+      method
+    end
+    it 'should move @pools to @pools_old' do
+      pools_old = inst_get(:@pools)
+      method
+      expect(inst_get(:@pools_old)).to be(pools_old)
+    end
+    it 'should stop unneeded pools' do
+      @method = :stop
+      @result = [:hash2]
+      check_set_op
+    end
+    it 'should start the new pools' do
+      @method = :start
+      @result = [:hash3, :hash4]
+      check_set_op
+    end
+  end
+  describe '#check_pools_n' do
+    it 'forwards to pools_action' do
+      hash = {
+        :hash1 => { :name => :map1},
+        :hash2 => { :name => :map2},
+      }
+      inst_set :@pools, hash
+      args = [hash, hash.keys, :check]
+      expect(a_i).to receive(:pools_action) do |*my_args|
+        expect(my_args).to eq(args)
+      end.once
+      method
+    end
+  end
+  describe '#pools_action' do
+    let!(:templates) {
+      @objects = [ double('object1'), double('object2') ]
+      @hash = {
+        :hash1 => { :name => :map1, :object => @objects[0]},
+        :hash2 => { :name => :map2, :object => @objects[1]},
+      }
+    }
+    let(:method_with_args){
+      @objects.each do |obj|
+        expect(obj).to receive(@method)
+      end
+      method(@hash, @hash.keys, @method)
+    }
+    it 'all pools run without error' do
+      @method = :start
+      expect(@dbl_logger_instance).not_to receive(:warn)
+      templates
+      method_with_args
+    end
+    it 'all pools error' do
+      @method = :start
+      error = 'servus der error'
+      expect(@dbl_logger_instance).to receive(:warn) do |pool,&block|
+        expect(block.call).to match(/#{error}/)
+      end.twice
+      templates
+      @objects.each do |obj|
+        expect(obj).to receive(@method).and_raise(RuntimeError, error)
+      end
+      method(@hash, @hash.keys, @method)
+    end
+  end
+end