synapse-aurora 0.11.2

data/lib/synapse/version.rb

@@ -0,0 +1,3 @@
+module Synapse
+  VERSION = "0.11.2"
+end

data/spec/lib/synapse/haproxy_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+class MockWatcher; end;
+
+describe Synapse::Haproxy do
+  subject { Synapse::Haproxy.new(config['haproxy']) }
+
+  let(:mockwatcher) do
+    mockWatcher = double(Synapse::ServiceWatcher)
+    allow(mockWatcher).to receive(:name).and_return('example_service')
+    backends = [{ 'host' => 'somehost', 'port' => '5555'}]
+    allow(mockWatcher).to receive(:backends).and_return(backends)
+    allow(mockWatcher).to receive(:haproxy).and_return({'server_options' => "check inter 2000 rise 3 fall 2"})
+    mockWatcher
+  end
+
+  it 'updating the config' do
+    expect(subject).to receive(:generate_config)
+    subject.update_config([mockwatcher])
+  end
+
+  it 'generates backend stanza' do
+    mockConfig = []
+    expect(subject.generate_backend_stanza(mockwatcher, mockConfig)).to eql(["\nbackend example_service", [], ["\tserver somehost:5555 somehost:5555 cookie somehost:5555 check inter 2000 rise 3 fall 2"]])
+  end
+
+  it 'generates backend stanza without cookies for tcp mode' do
+    mockConfig = ['mode tcp']
+    expect(subject.generate_backend_stanza(mockwatcher, mockConfig)).to eql(["\nbackend example_service", ["\tmode tcp"], ["\tserver somehost:5555 somehost:5555 check inter 2000 rise 3 fall 2"]])
+  end
+
+end

data/spec/lib/synapse/service_watcher_base_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+class Synapse::BaseWatcher
+  attr_reader :should_exit, :default_servers
+end
+
+describe Synapse::BaseWatcher do
+  let(:mocksynapse) { double() }
+  subject { Synapse::BaseWatcher.new(args, mocksynapse) } 
+  let(:testargs) { { 'name' => 'foo', 'discovery' => { 'method' => 'base' }, 'haproxy' => {} }}
+
+  def remove_arg(name)
+    args = testargs.clone
+    args.delete name
+    args
+  end
+
+  context "can construct normally" do
+    let(:args) { testargs }
+    it('can at least construct') { expect { subject }.not_to raise_error }
+  end
+
+  ['name', 'discovery', 'haproxy'].each do |to_remove|
+    context "without #{to_remove} argument" do
+      let(:args) { remove_arg to_remove }
+      it('gots bang') { expect { subject }.to raise_error(ArgumentError, "missing required option #{to_remove}") }
+    end
+  end
+
+  context "normal tests" do
+    let(:args) { testargs }
+    it('is running') { expect(subject.should_exit).to equal(false) }
+    it('can ping') { expect(subject.ping?).to equal(true) }
+    it('can be stopped') do
+      subject.stop
+      expect(subject.should_exit).to equal(true)
+    end
+  end
+
+  context "with default_servers" do
+    default_servers = ['server1', 'server2']
+    let(:args) { testargs.merge({'default_servers' => default_servers}) }
+    it('sets default backends to default_servers') { expect(subject.backends).to equal(default_servers) }
+
+    context "with keep_default_servers set" do
+      let(:args) { testargs.merge({'default_servers' => default_servers, 'keep_default_servers' => true}) }
+      let(:new_backends) { ['discovered1', 'discovered2'] }
+
+      it('keeps default_servers when setting backends') do
+        subject.send(:set_backends, new_backends)
+        expect(subject.backends).to eq(default_servers + new_backends)
+      end
+    end
+  end
+end

data/spec/lib/synapse/service_watcher_docker_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+class Synapse::DockerWatcher
+  attr_reader :check_interval, :watcher, :synapse
+  attr_accessor :default_servers
+end
+
+describe Synapse::DockerWatcher do
+  let(:mocksynapse) { double() }
+  subject { Synapse::DockerWatcher.new(testargs, mocksynapse) }
+  let(:testargs) { { 'name' => 'foo', 'discovery' => { 'method' => 'docker', 'servers' => [{'host' => 'server1.local', 'name' => 'mainserver'}], 'image_name' => 'mycool/image', 'container_port' => 6379 }, 'haproxy' => {} }}
+  before(:each) do
+    allow(subject.log).to receive(:warn)
+    allow(subject.log).to receive(:info)
+  end
+
+  def add_arg(name, value)
+    args = testargs.clone
+    args['discovery'][name] = value
+    args
+  end
+
+  context "can construct normally" do
+    it('can at least construct') { expect { subject }.not_to raise_error }
+  end
+
+  context "normal tests" do
+    it('starts a watcher thread') do
+      watcher_mock = double()
+      expect(Thread).to receive(:new).and_return(watcher_mock)
+      subject.start
+      expect(subject.watcher).to equal(watcher_mock)
+    end
+    it('sets default check interval') do
+      expect(Thread).to receive(:new).and_return(double)
+      subject.start
+      expect(subject.check_interval).to eq(15.0)
+    end
+  end
+
+  context "watch tests" do
+    before(:each) do
+      expect(subject).to receive(:sleep_until_next_check) do |arg|
+        subject.instance_variable_set('@should_exit', true)
+      end
+    end
+    it('has a happy first run path, configuring backends') do
+      expect(subject).to receive(:containers).and_return(['container1'])
+      expect(subject).to receive(:configure_backends).with(['container1'])
+      subject.send(:watch)
+    end
+    it('does not call configure_backends if there is no change') do
+      expect(subject).to receive(:containers).and_return([])
+      expect(subject).to_not receive(:configure_backends)
+      subject.send(:watch)
+    end
+  end
+  context "watch eats exceptions" do
+    it "blows up when finding containers" do
+      expect(subject).to receive(:containers) do |arg|
+        subject.instance_variable_set('@should_exit', true)
+        raise('throw exception inside watch')
+      end
+      expect { subject.send(:watch) }.not_to raise_error
+    end
+  end
+
+  context "configure_backends tests" do
+    before(:each) do
+      expect(subject.synapse).to receive(:'reconfigure!').at_least(:once)
+    end
+    it 'runs' do
+      expect { subject.send(:configure_backends, []) }.not_to raise_error
+    end
+    it 'sets backends right' do
+      subject.send(:configure_backends, ['foo'])
+      expect(subject.backends).to eq(['foo'])
+    end
+    it 'resets to default backends if no container found' do
+      subject.default_servers = ['fallback1']
+      subject.send(:configure_backends, ['foo'])
+      expect(subject.backends).to eq(['foo'])
+      subject.send(:configure_backends, [])
+      expect(subject.backends).to eq(['fallback1'])
+    end
+    it 'does not reset to default backends if there are no default backends' do
+      subject.default_servers = []
+      subject.send(:configure_backends, ['foo'])
+      expect(subject.backends).to eq(['foo'])
+      subject.send(:configure_backends, [])
+      expect(subject.backends).to eq(['foo'])
+    end
+  end
+
+  context "rewrite_container_ports tests" do
+    it 'doesnt break if Ports => nil' do
+        subject.send(:rewrite_container_ports, nil)
+    end
+    it 'works for old style port mappings' do
+      expect(subject.send(:rewrite_container_ports, "0.0.0.0:49153->6379/tcp, 0.0.0.0:49154->6390/tcp")).to \
+        eql({'6379' => '49153', '6390' => '49154'})
+    end
+    it 'works for new style port mappings' do
+      expect(subject.send(:rewrite_container_ports, [{'PrivatePort' => 6379, 'PublicPort' => 49153}, {'PublicPort' => 49154, 'PrivatePort' => 6390}])).to \
+        eql({'6379' => '49153', '6390' => '49154'})
+    end
+  end
+
+  context "container discovery tests" do
+    before(:each) do
+      getter = double()
+      expect(getter).to receive(:get)
+      expect(Docker).to receive(:connection).and_return(getter)
+    end
+
+    it('has a sane uri') { subject.send(:containers); expect(Docker.url).to eql('http://server1.local:4243') }
+
+    context 'old style port mappings' do
+      context 'works for one container' do
+        let(:docker_data) { [{"Ports" => "0.0.0.0:49153->6379/tcp, 0.0.0.0:49154->6390/tcp", "Image" => "mycool/image:tagname"}] }
+        it do 
+          expect(Docker::Util).to receive(:parse_json).and_return(docker_data)
+          expect(subject.send(:containers)).to eql([{"name"=>"mainserver", "host"=>"server1.local", "port"=>"49153"}])
+         end
+      end
+      context 'works for multiple containers' do
+        let(:docker_data) { [{"Ports" => "0.0.0.0:49153->6379/tcp, 0.0.0.0:49154->6390/tcp", "Image" => "mycool/image:tagname"}, {"Ports" => "0.0.0.0:49155->6379/tcp", "Image" => "mycool/image:tagname"}] }
+        it do
+          expect(Docker::Util).to receive(:parse_json).and_return(docker_data)
+          expect(subject.send(:containers)).to eql([{"name"=>"mainserver", "host"=>"server1.local", "port"=>"49153"},{"name"=>"mainserver", "host"=>"server1.local", "port"=>"49155"}])
+        end
+      end
+    end
+
+    context 'new style port mappings' do
+      let(:docker_data) { [{"Ports" => [{'PrivatePort' => 6379, 'PublicPort' => 49153}, {'PublicPort' => 49154, 'PrivatePort' => 6390}], "Image" => "mycool/image:tagname"}] }
+      it do
+        expect(Docker::Util).to receive(:parse_json).and_return(docker_data)
+        expect(subject.send(:containers)).to eql([{"name"=>"mainserver", "host"=>"server1.local", "port"=>"49153"}])
+      end
+    end
+
+    context 'filters out wrong images' do
+      let(:docker_data) { [{"Ports" => "0.0.0.0:49153->6379/tcp, 0.0.0.0:49154->6390/tcp", "Image" => "mycool/image:tagname"}, {"Ports" => "0.0.0.0:49155->6379/tcp", "Image" => "wrong/image:tagname"}] }
+      it do
+        expect(Docker::Util).to receive(:parse_json).and_return(docker_data)
+        expect(subject.send(:containers)).to eql([{"name"=>"mainserver", "host"=>"server1.local", "port"=>"49153"}])
+      end
+    end
+  end
+end
+

data/spec/lib/synapse/service_watcher_ec2tags_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+require 'logging'
+
+class Synapse::EC2Watcher
+  attr_reader   :synapse
+  attr_accessor :default_servers, :ec2
+end
+
+class FakeAWSInstance
+  def ip_address
+    @ip_address ||= fake_address
+  end
+
+  def private_ip_address
+    @private_ip_address ||= fake_address
+  end
+
+  def dns_name
+    @dns_name ||= "ec2-#{ip_address.gsub('.', '-')}.eu-test-1.compute.amazonaws.com"
+  end
+
+  def private_dns_name
+    @private_dns_name ||= "ip-#{private_ip_address.gsub('.', '-')}.eu-test-1.compute.internal"
+  end
+
+  def fake_address
+    4.times.map { (0...254).to_a.shuffle.pop.to_s }.join('.')
+  end
+end
+
+describe Synapse::EC2Watcher do
+  let(:mock_synapse) { double }
+  subject { Synapse::EC2Watcher.new(basic_config, mock_synapse) }
+
+  let(:basic_config) do
+    { 'name' => 'ec2tagtest',
+      'haproxy' => {
+        'port' => '8080',
+        'server_port_override' => '8081'
+      },
+      "discovery" => {
+        "method" => "ec2tag",
+        "tag_name"   => "fuNNy_tag_name",
+        "tag_value"  => "funkyTagValue",
+        "aws_region" => 'eu-test-1',
+        "aws_access_key_id" => 'ABCDEFGHIJKLMNOPQRSTU',
+        "aws_secret_access_key" => 'verylongfakekeythatireallyneedtogenerate'
+      }
+    }
+  end
+
+  before(:all) do
+    # Clean up ENV so we don't inherit any actual AWS config.
+    %w[AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION].each { |k| ENV.delete(k) }
+  end
+
+  before(:each) do
+    # https://ruby.awsblog.com/post/Tx2SU6TYJWQQLC3/Stubbing-AWS-Responses
+    # always returns empty results, so data may have to be faked.
+    AWS.stub!
+  end
+
+  def remove_discovery_arg(name)
+    args = basic_config.clone
+    args['discovery'].delete name
+    args
+  end
+
+  def remove_haproxy_arg(name)
+    args = basic_config.clone
+    args['haproxy'].delete name
+    args
+  end
+
+  def munge_haproxy_arg(name, new_value)
+    args = basic_config.clone
+    args['haproxy'][name] = new_value
+    args
+  end
+
+  describe '#new' do
+    let(:args) { basic_config }
+
+    it 'instantiates cleanly with basic config' do
+      expect { subject }.not_to raise_error
+    end
+
+    context 'when missing arguments' do
+      it 'complains if aws_region is missing' do
+        expect {
+          Synapse::EC2Watcher.new(remove_discovery_arg('aws_region'), mock_synapse)
+        }.to raise_error(ArgumentError, /Missing aws_region/)
+      end
+      it 'complains if aws_access_key_id is missing' do
+        expect {
+          Synapse::EC2Watcher.new(remove_discovery_arg('aws_access_key_id'), mock_synapse)
+        }.to raise_error(ArgumentError, /Missing aws_access_key_id/)
+      end
+      it 'complains if aws_secret_access_key is missing' do
+        expect {
+          Synapse::EC2Watcher.new(remove_discovery_arg('aws_secret_access_key'), mock_synapse)
+        }.to raise_error(ArgumentError, /Missing aws_secret_access_key/)
+      end
+      it 'complains if server_port_override is missing' do
+        expect {
+          Synapse::EC2Watcher.new(remove_haproxy_arg('server_port_override'), mock_synapse)
+        }.to raise_error(ArgumentError, /Missing server_port_override/)
+      end
+    end
+
+    context 'invalid data' do
+      it 'complains if the haproxy server_port_override is not a number' do
+          expect {
+            Synapse::EC2Watcher.new(munge_haproxy_arg('server_port_override', '80deadbeef'), mock_synapse)
+          }.to raise_error(ArgumentError, /Invalid server_port_override/)
+      end
+    end
+  end
+
+  context "instance discovery" do
+    let(:instance1) { FakeAWSInstance.new }
+    let(:instance2) { FakeAWSInstance.new }
+
+    context 'using the AWS API' do
+      let(:ec2_client) { double('AWS::EC2') }
+      let(:instance_collection) { double('AWS::EC2::InstanceCollection') }
+
+      before do
+        subject.ec2 = ec2_client
+      end
+
+      it 'fetches instances and filter instances' do
+        # Unfortunately there's quite a bit going on here, but this is
+        # a chained call to get then filter EC2 instances, which is
+        # done remotely; breaking into separate calls would result in
+        # unnecessary data being retrieved.
+
+        subject.ec2.should_receive(:instances).and_return(instance_collection)
+
+        instance_collection.should_receive(:tagged).with('foo').and_return(instance_collection)
+        instance_collection.should_receive(:tagged_values).with('bar').and_return(instance_collection)
+        instance_collection.should_receive(:select).and_return(instance_collection)
+
+        subject.send(:instances_with_tags, 'foo', 'bar')
+      end
+    end
+
+    context 'returned backend data structure' do
+      before do
+        subject.stub(:instances_with_tags).and_return([instance1, instance2])
+      end
+
+      let(:backends) { subject.send(:discover_instances) }
+
+      it 'returns an Array of backend name/host/port Hashes' do
+
+        expect { backends.all? {|b| %w[name host port].each {|k| b.has_key?(k) }} }.to be_true
+      end
+
+      it 'sets the backend port to server_port_override for all backends' do
+        backends = subject.send(:discover_instances)
+        expect {
+          backends.all? { |b| b['port'] == basic_config['haproxy']['server_port_override'] }
+        }.to be_true
+      end
+    end
+
+    context 'returned instance fields' do
+      before do
+        subject.stub(:instances_with_tags).and_return([instance1])
+      end
+
+      let(:backend) { subject.send(:discover_instances).pop }
+
+      it "returns an instance's private IP as the hostname" do
+        expect( backend['host'] ).to eq instance1.private_ip_address
+      end
+
+      it "returns an instance's private hostname as the server name" do
+        expect( backend['name'] ).to eq instance1.private_dns_name
+      end
+    end
+  end
+
+  context "configure_backends tests" do
+    let(:backend1) { { 'name' => 'foo',  'host' => 'foo.backend.tld',  'port' => '123' } }
+    let(:backend2) { { 'name' => 'bar',  'host' => 'bar.backend.tld',  'port' => '456' } }
+    let(:fallback) { { 'name' => 'fall', 'host' => 'fall.backend.tld', 'port' => '789' } }
+
+    before(:each) do
+      expect(subject.synapse).to receive(:'reconfigure!').at_least(:once)
+    end
+
+    it 'runs' do
+      expect { subject.send(:configure_backends, []) }.not_to raise_error
+    end
+
+    it 'sets backends correctly' do
+      subject.send(:configure_backends, [ backend1, backend2 ])
+      expect(subject.backends).to eq([ backend1, backend2 ])
+    end
+
+    it 'resets to default backends if no instances are found' do
+      subject.default_servers = [ fallback ]
+      subject.send(:configure_backends, [ backend1 ])
+      expect(subject.backends).to eq([ backend1 ])
+      subject.send(:configure_backends, [])
+      expect(subject.backends).to eq([ fallback ])
+    end
+
+    it 'does not reset to default backends if there are no default backends' do
+      subject.default_servers = []
+      subject.send(:configure_backends, [ backend1 ])
+      expect(subject.backends).to eq([ backend1 ])
+      subject.send(:configure_backends, [])
+      expect(subject.backends).to eq([ backend1 ])
+    end
+  end
+end
+