proxymgr 0.1

data/spec/support/mock_servers.rb

@@ -0,0 +1,7 @@
+module MockServers
+  def new_mock_server(backend, name, status = nil)
+    ProxyMgr::Haproxy::Server.new(nil, {'pxname' => backend,
+                                        'svname' => name,
+                                        'status' => status})
+  end
+end

data/spec/unit/haproxy/socket_manager_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ProxyMgr::Haproxy::SocketManager, '#update' do
+  before(:each) do
+    @sm = ProxyMgr::Haproxy::SocketManager.new
+    Socket.any_instance.stub(:bind) { true }
+  end
+
+  it 'creates new sockets when none exist' do
+    watcher = double(ProxyMgr::Watcher::Base)
+    watcher.stub(:port) { 9090 }
+    @sm.update({"test" => watcher})
+    @sm.sockets[9090].should be_kind_of(Socket)
+  end
+
+  it 'deletes sockets which are no longer part of the state' do
+    ports = [9090, 9091]
+    watchers = Hash[ports.map do |port|
+      watcher = double(ProxyMgr::Watcher::Base)
+      watcher.stub(:port) { port }
+      ["service_" + port.to_s, watcher]
+    end]
+    @sm.update(watchers)
+    ports.each do |port|
+      @sm.sockets[port].should be_kind_of(Socket)
+    end
+    watchers.delete("service_9090")
+    Socket.any_instance.should_receive(:close)
+    @sm.update(watchers)
+    @sm.sockets[9091].should be_kind_of(Socket)
+    @sm.sockets[9090].should == nil
+  end
+
+  it 'sets SO_REUSEADDR on sockets' do
+    watcher = double(ProxyMgr::Watcher::Base)
+    watcher.stub(:port) { 9090 }
+    Socket.any_instance.should_receive(:setsockopt).with(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, 1)
+    @sm.update("test" => watcher)
+  end
+end

data/spec/unit/haproxy/updater_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe ProxyMgr::Haproxy::Updater, '#produce_changeset' do
+  before do
+    @socket  = double(ProxyMgr::Haproxy::Socket)
+    @sm      = double(ProxyMgr::ServiceManager)
+    @updater = ProxyMgr::Haproxy::Updater.new(@socket)
+  end
+
+  context 'stats socket not available' do
+    before do
+      @socket.stub(:connected?) { false }
+    end
+
+    it 'should require restarts if no stats socket is available' do
+      @socket.stub(:connected?) { false }
+      changeset = @updater.produce_changeset(nil)
+      changeset.restart_needed?.should == true
+    end
+  end
+
+  context 'stats socket available' do
+    before do
+      @socket.stub(:connected?) { true }
+    end
+
+    it 'requires restarts if a new server is provided' do
+      @socket.should_receive(:servers) do
+        ['a', 'b'].map { |name| new_mock_server('dummy', 'name') }
+      end
+      watcher = ProxyMgr::Watcher::Dummy.new('dummy', {}, @sm)
+      watcher.servers = ['a', 'b', 'c']
+      changeset = @updater.produce_changeset('dummy' => watcher)
+      changeset.restart_needed?.should == true
+    end
+
+    it 'disables servers if they are already added' do
+      @socket.should_receive(:servers) { [] }
+      watcher = ProxyMgr::Watcher::Dummy.new('dummy', {}, @sm)
+      watcher.servers = ['a', 'b', 'c']
+      @updater.produce_changeset('dummy' => watcher)
+      @socket.should_receive(:servers) do
+        ['a', 'b', 'c'].map { |name| new_mock_server('dummy', name) }
+      end
+      watcher = ProxyMgr::Watcher::Dummy.new('dummy', {}, @sm)
+      watcher.servers = ['a', 'b']
+      changeset = @updater.produce_changeset('dummy' => watcher)
+      changeset.disable.should == {'dummy' => ['c']}
+      changeset.restart_needed?.should == false
+    end
+
+    it 'enables servers if they are down and added' do
+      @socket.should_receive(:servers) { [] }
+      watcher = ProxyMgr::Watcher::Dummy.new('dummy', {}, @sm)
+      watcher.servers = []
+      @updater.produce_changeset('dummy' => watcher)
+      @socket.should_receive(:servers) do
+        s = ['a', 'b'].map { |name| new_mock_server('dummy', name) }
+        s << new_mock_server('dummy', 'c', 'MAINT')
+      end
+      watcher = ProxyMgr::Watcher::Dummy.new('dummy', {}, @sm)
+      watcher.servers = ['a', 'b', 'c']
+      changeset = @updater.produce_changeset('dummy' => watcher)
+      changeset.enable.should == {'dummy' => ['c']}
+      changeset.restart_needed?.should == false
+    end
+
+    it 'requires restart if a backend is added' do
+      @socket.should_receive(:servers) { [] }
+      watcher = double(ProxyMgr::Watcher::Base)
+      watcher.should_receive(:servers) { ['a', 'b'] }
+      changeset = @updater.produce_changeset('dummy' => watcher)
+      changeset.restart_needed?.should == true
+    end
+
+    it 'requires a restart if a server has not already been added/is disabled' do
+      @socket.stub(:servers) do
+        ['a', 'b'].map do |name|
+          new_mock_server('dummy', name)
+        end
+      end
+      watcher = double(ProxyMgr::Watcher::Base)
+      watcher.should_receive(:servers) { ['a', 'b'] }
+      changeset = @updater.produce_changeset('dummy' => watcher)
+      watcher.should_receive(:servers) { ['a', 'b', 'c'] }
+      changeset = @updater.produce_changeset('dummy' => watcher)
+      changeset.restart_needed?.should == true
+    end
+
+    it 'requires restart if a backend is deleted' do
+      @socket.stub(:servers) do
+        ['a', 'b'].map do |name|
+          new_mock_server('dummy', name)
+        end
+        ['c', 'd'].map do |name|
+          new_mock_server('dummy2', name)
+        end
+      end
+      watcher1 = ProxyMgr::Watcher::Dummy.new('dummy', {}, @sm).tap do |w|
+        w.servers = ['a', 'b']
+      end
+      watcher2 = ProxyMgr::Watcher::Dummy.new('dummy2', {}, @sm).tap do |w|
+        w.servers = ['c', 'd']
+      end
+      @updater.produce_changeset('dummy'  => watcher1,
+                                 'dummy2' => watcher2)
+      changeset = @updater.produce_changeset('dummy' => watcher1)
+      changeset.restart_needed?.should == true
+    end
+
+    it 'requires restarting if listen_options is changed' do
+      @socket.should_receive(:servers) { [] }
+      watcher = ProxyMgr::Watcher::Dummy.new('dummy', {}, @sm)
+      watcher.servers = ['a']
+      @updater.produce_changeset('dummy' => watcher)
+      @socket.should_receive(:servers) { [new_mock_server('dummy', 'a')] }
+      watcher = ProxyMgr::Watcher::Dummy.new('dummy', {'listen_options' => ['test option']}, @sm)
+      watcher.servers = ['a']
+      changeset = @updater.produce_changeset('dummy' => watcher)
+      changeset.restart_needed?.should == true
+    end
+  end
+end

data/spec/unit/service_manager_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe ProxyMgr::ServiceManager do
+  before(:each) do
+    @sink    = double(ProxyMgr::Sink)
+    @manager = ProxyMgr::ServiceManager.new(@sink)
+  end
+
+  it 'adds new services' do
+    expect(ProxyMgr::Watcher::Dummy).to receive(:new).with('dummy', {'config' => 'thing'}, @manager)
+    @manager.update_service('dummy', {'type' => 'dummy', 'config' => 'thing'})
+  end
+
+  it 'starts services if valid' do
+    expect_any_instance_of(ProxyMgr::Watcher::Dummy).to receive(:watch)
+    ProxyMgr::Watcher::Dummy.any_instance.stub(:valid?) { true }
+    @manager.update_service('dummy', {'type' => 'dummy', 'config' => 'thing'})
+  end
+
+  it 'shuts down old services when replaced' do
+    @manager.update_service('dummy', {'type' => "dummy"})
+    expect_any_instance_of(ProxyMgr::Watcher::Dummy).to receive(:shutdown)
+    @manager.update_service('dummy', {'type' => "dummy"})
+  end
+
+  it 'shuts down serviecs when deleted and notifies sink' do
+    @sink.should_receive(:update_backends)
+    @manager.update_service('dummy', {'type' => "dummy"})
+    expect_any_instance_of(ProxyMgr::Watcher::Dummy).to receive(:shutdown)
+    @manager.delete_service('dummy')
+  end
+
+  it 'notifies sink when watchers are updated' do
+    @manager.update_service('dummy', {'type' => 'dummy'})
+    @sink.should_receive(:update_backends)
+    @manager.update_backends
+  end
+
+  it 'shuts down all services and sink when shut down' do
+    @manager.update_service('dummy', {'type' => 'dummy'})
+    expect_any_instance_of(ProxyMgr::Watcher::Dummy).to receive(:shutdown)
+    @sink.should_receive(:shutdown)
+    @manager.shutdown
+  end
+
+  it 'does not create services for non-existing watcher types' do
+    @manager.update_service('dummy', {'type' => 'NonExisting'}).should == nil
+  end
+end

data/spec/unit/sink_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe ProxyMgr::Sink do
+  require 'absolute_time'
+
+  before(:each) do
+    @manager = double(ProxyMgr::ServiceManager)
+    @watcher = ProxyMgr::Watcher::Dummy.new('test', {'port' => 1}, @manager)
+    @watcher.servers = ['a', 'b']
+    @mutex   = Mutex.new
+    @cv      = ConditionVariable.new
+  end
+
+  it 'calls update_backends after a delay' do
+    t1       = AbsoluteTime.now
+    elapsed  = nil
+    proxy    = ProxyMgr::FakeProxy.new do
+      elapsed = AbsoluteTime.now-t1
+      @mutex.synchronize { @cv.signal }
+    end
+    sink     = ProxyMgr::Sink.new(proxy, :default_timeout => 2)
+    sink.update_backends('test' => @watcher)
+    @mutex.synchronize { @cv.wait(@mutex) }
+    elapsed.should >= 2
+  end
+
+  it 'calls update_backends with increasing delay if interrupted' do
+    t1       = AbsoluteTime.now
+    elapsed  = nil
+    proxy    = ProxyMgr::FakeProxy.new do
+      elapsed = AbsoluteTime.now-t1
+      @mutex.synchronize { @cv.signal }
+    end
+    sink     = ProxyMgr::Sink.new(proxy, :default_timeout => 2)
+    sink.update_backends('test' => @watcher)
+    sleep(1) # this is a bit of a hack. but the semantics don't lend themselves to testing very well.
+    sink.update_backends('test' => @watcher, 'test2' => @watcher)
+    @mutex.synchronize { @cv.wait(@mutex) }
+    elapsed.should >= 4
+  end
+end

data/spec/unit/watcher/base_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ProxyMgr::Watcher::Base do
+  before(:each) do
+    @sm = double(ProxyMgr::ServiceManager)
+  end
+
+  it 'is valid if port is correctly specified' do
+    watcher = ProxyMgr::Watcher::Dummy.new('test', {'port' => 8080}, @sm)
+    watcher.valid?.should == true
+  end
+
+  it 'does not start if port is not an integer' do
+    watcher = ProxyMgr::Watcher::Dummy.new('test', {'port' => 'false'}, @sm)
+    watcher.valid?.should == false
+  end
+
+  it 'does not start if port is invalid' do
+    watcher = ProxyMgr::Watcher::Dummy.new('test', {'port' => 0}, @sm)
+    watcher.valid?.should == false
+  end
+
+  it 'is valid if listen_options specified and is an array' do
+    watcher = ProxyMgr::Watcher::Dummy.new('test', {'port' => 65535, 'listen_options' => ['a config option', 'another']}, @sm)
+    watcher.valid?.should == true
+  end
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: proxymgr
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Torbjörn Norinder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docopt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: zoology
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: absolute_time
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: zookeeper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Manages Haproxy configuration dynamically
+email:
+- torbjorn@genunix.se
+executables:
+- proxymgr
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/proxymgr
+- etc/haproxy.cfg.erb
+- examples/config.yml
+- lib/proxymgr.rb
+- lib/proxymgr/callbacks.rb
+- lib/proxymgr/config.rb
+- lib/proxymgr/haproxy.rb
+- lib/proxymgr/haproxy/control.rb
+- lib/proxymgr/haproxy/process.rb
+- lib/proxymgr/haproxy/server.rb
+- lib/proxymgr/haproxy/socket.rb
+- lib/proxymgr/haproxy/socket_manager.rb
+- lib/proxymgr/haproxy/state.rb
+- lib/proxymgr/haproxy/updater.rb
+- lib/proxymgr/logging.rb
+- lib/proxymgr/platform.rb
+- lib/proxymgr/platform/linux.rb
+- lib/proxymgr/process_manager.rb
+- lib/proxymgr/process_manager/signal_handler.rb
+- lib/proxymgr/service_config.rb
+- lib/proxymgr/service_config/base.rb
+- lib/proxymgr/service_config/zookeeper.rb
+- lib/proxymgr/service_manager.rb
+- lib/proxymgr/sink.rb
+- lib/proxymgr/watcher.rb
+- lib/proxymgr/watcher/base.rb
+- lib/proxymgr/watcher/campanja_zk.rb
+- lib/proxymgr/watcher/dns.rb
+- lib/proxymgr/watcher/file.rb
+- lib/proxymgr/watcher/zookeeper.rb
+- packaging/profile.sh
+- packaging/recipe.rb
+- proxymgr.gemspec
+- spec/spec_helper.rb
+- spec/support/dummy_watcher.rb
+- spec/support/fake_proxy.rb
+- spec/support/fake_zookeeper.rb
+- spec/support/mock_servers.rb
+- spec/unit/haproxy/socket_manager_spec.rb
+- spec/unit/haproxy/updater_spec.rb
+- spec/unit/service_manager_spec.rb
+- spec/unit/sink_spec.rb
+- spec/unit/watcher/base_spec.rb
+homepage: https://github.com/campanja/proxymgr
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Manages Haproxy configuration dynamically
+test_files:
+- spec/spec_helper.rb
+- spec/support/dummy_watcher.rb
+- spec/support/fake_proxy.rb
+- spec/support/fake_zookeeper.rb
+- spec/support/mock_servers.rb
+- spec/unit/haproxy/socket_manager_spec.rb
+- spec/unit/haproxy/updater_spec.rb
+- spec/unit/service_manager_spec.rb
+- spec/unit/sink_spec.rb
+- spec/unit/watcher/base_spec.rb