synapse 0.12.1 → 0.12.2

data/lib/synapse/service_watcher/dns.rb

@@ -3,7 +3,7 @@ require "synapse/service_watcher/base"
 require 'thread'
 require 'resolv'
 
-module Synapse
+class Synapse::ServiceWatcher
   class DnsWatcher < BaseWatcher
     def start
       @check_interval = @discovery['check_interval'] || 30.0

data/lib/synapse/service_watcher/docker.rb

@@ -1,7 +1,7 @@
 require "synapse/service_watcher/base"
 require 'docker'
 
-module Synapse
+class Synapse::ServiceWatcher
   class DockerWatcher < BaseWatcher
     def start
       @check_interval = @discovery['check_interval'] || 15.0
@@ -74,10 +74,11 @@ module Synapse
         cnts.each do |cnt|
           cnt['Ports'] = rewrite_container_ports cnt['Ports']
         end
-        # Discover containers that match the image/port we're interested in
+        # Discover containers that match the image/port we're interested in and have the port mapped to the host
         cnts = cnts.find_all do |cnt|
           cnt["Image"].rpartition(":").first == @discovery["image_name"] \
-            and cnt["Ports"].has_key?(@discovery["container_port"].to_s())
+            and cnt["Ports"].has_key?(@discovery["container_port"].to_s()) \
+            and cnt["Ports"][@discovery["container_port"].to_s()].length > 0
         end
         cnts.map do |cnt|
           {

data/lib/synapse/service_watcher/ec2tag.rb

@@ -1,8 +1,8 @@
 require 'synapse/service_watcher/base'
 require 'aws-sdk'
 
-module Synapse
-  class EC2Watcher < BaseWatcher
+class Synapse::ServiceWatcher
+  class Ec2tagWatcher < BaseWatcher
 
     attr_reader :check_interval
 
@@ -41,15 +41,18 @@ module Synapse
           "Missing server_port_override for service #{@name} - which port are backends listening on?"
       end
 
-      unless @haproxy['server_port_override'].match(/^\d+$/)
+      unless @haproxy['server_port_override'].to_s.match(/^\d+$/)
         raise ArgumentError, "Invalid server_port_override value"
       end
 
-      # Required, but can use well-known environment variables.
-      %w[aws_access_key_id aws_secret_access_key aws_region].each do |attr|
-        unless (@discovery[attr] || ENV[attr.upcase])
-          raise ArgumentError, "Missing #{attr} option or #{attr.upcase} environment variable"
-        end
+      # aws region is optional in the SDK, aws will use a default value if not provided
+      unless @discovery['aws_region'] || ENV['AWS_REGION']
+        log.info "aws region is missing, will use default"
+      end
+      # access key id & secret are optional, might be using IAM instance profile for credentials
+      unless ((@discovery['aws_access_key_id'] || ENV['aws_access_key_id']) \
+              && (@discovery['aws_secret_access_key'] || ENV['aws_secret_access_key'] ))
+        log.info "aws access key id & secret not set in config or env variables for service #{name}, will attempt to use IAM instance profile"
       end
     end
 
@@ -60,10 +63,11 @@ module Synapse
           if set_backends(discover_instances)
             log.info "synapse: ec2tag watcher backends have changed."
           end
-          sleep_until_next_check(start)
         rescue Exception => e
           log.warn "synapse: error in ec2tag watcher thread: #{e.inspect}"
           log.warn e.backtrace
+        ensure
+          sleep_until_next_check(start)
         end
       end
 

data/lib/synapse/service_watcher/marathon.rb

@@ -0,0 +1,112 @@
+require 'synapse/service_watcher/base'
+require 'json'
+require 'net/http'
+require 'resolv'
+
+class Synapse::ServiceWatcher
+  class MarathonWatcher < BaseWatcher
+    def start
+      @check_interval = @discovery['check_interval'] || 10.0
+      @connection = nil
+      @watcher = Thread.new { sleep splay; watch }
+    end
+
+    def stop
+      @connection.finish
+    rescue
+      # pass
+    end
+
+  private
+
+    def validate_discovery_opts
+      required_opts = %w[marathon_api_url application_name]
+
+      required_opts.each do |opt|
+        if @discovery.fetch(opt, '').empty?
+          raise ArgumentError,
+            "a value for services.#{@name}.discovery.#{opt} must be specified"
+        end
+      end
+    end
+
+    def attempt_marathon_connection
+      marathon_api_path = @discovery.fetch('marathon_api_path', '/v2/apps/%{app}/tasks')
+      marathon_api_path = marathon_api_path % { app: @discovery['application_name'] }
+
+      @marathon_api = URI.join(@discovery['marathon_api_url'], marathon_api_path)
+
+      begin
+        @connection = Net::HTTP.new(@marathon_api.host, @marathon_api.port)
+        @connection.open_timeout = 5
+        @connection.start
+      rescue => ex
+        @connection = nil
+        log.error "synapse: could not connect to marathon at #{@marathon_api}: #{ex}"
+
+        raise ex
+      end
+    end
+
+    def watch
+      until @should_exit
+        retry_count = 0
+        start = Time.now
+
+        begin
+          if @connection.nil?
+            attempt_marathon_connection
+          end
+
+          req = Net::HTTP::Get.new(@marathon_api.request_uri)
+          req['Accept'] = 'application/json'
+          response = @connection.request(req)
+
+          tasks = JSON.parse(response.body).fetch('tasks', [])
+          port_index = @discovery['port_index'] || 0
+          backends = tasks.keep_if { |task| task['startedAt'] }.map do |task|
+            {
+              'name' => task['host'],
+              'host' => task['host'],
+              'port' => task['ports'][port_index],
+            }
+          end.sort_by { |task| task['name'] }
+
+          invalid_backends = backends.find_all { |b| b['port'].nil? }
+          if invalid_backends.any?
+            backends = backends - invalid_backends
+
+            invalid_backends.each do |backend|
+              log.error "synapse: port index #{port_index} not found in task's port array!"
+            end
+          end
+
+          set_backends(backends)
+        rescue EOFError
+          # If the persistent HTTP connection is severed, we can automatically
+          # retry
+          log.info "synapse: marathon HTTP API disappeared, reconnecting..."
+
+          retry if (retry_count += 1) == 1
+        rescue => e
+          log.warn "synapse: error in watcher thread: #{e.inspect}"
+          log.warn e.backtrace.join("\n")
+          @connection = nil
+        ensure
+          elapsed_time = Time.now - start
+          sleep (@check_interval - elapsed_time) if elapsed_time < @check_interval
+        end
+
+        @should_exit = true if only_run_once? # for testability
+      end
+    end
+
+    def splay
+      Random.rand(@check_interval)
+    end
+
+    def only_run_once?
+      false
+    end
+  end
+end

data/lib/synapse/service_watcher/zookeeper.rb

@@ -3,7 +3,7 @@ require "synapse/service_watcher/base"
 require 'thread'
 require 'zk'
 
-module Synapse
+class Synapse::ServiceWatcher
   class ZookeeperWatcher < BaseWatcher
     NUMBERS_RE = /^\d+$/
 
@@ -61,7 +61,8 @@ module Synapse
         node = @zk.get("#{@discovery['path']}/#{id}")
 
         begin
-          host, port, name, weight = deserialize_service_instance(node.first)
+          # TODO: Do less munging, or refactor out this processing
+          host, port, name, weight, haproxy_server_options = deserialize_service_instance(node.first)
         rescue StandardError => e
           log.error "synapse: invalid data in ZK node #{id} at #{@discovery['path']}: #{e}"
         else
@@ -72,7 +73,11 @@ module Synapse
           numeric_id = NUMBERS_RE =~ numeric_id ? numeric_id.to_i : nil
 
           log.debug "synapse: discovered backend #{name} at #{host}:#{server_port} for service #{@name}"
-          new_backends << { 'name' => name, 'host' => host, 'port' => server_port, 'id' => numeric_id, 'weight' => weight }
+          new_backends << {
+            'name' => name, 'host' => host, 'port' => server_port,
+            'id' => numeric_id, 'weight' => weight,
+            'haproxy_server_options' => haproxy_server_options
+          }
         end
       end
 
@@ -84,13 +89,12 @@ module Synapse
       return if @zk.nil?
       log.debug "synapse: setting watch at #{@discovery['path']}"
 
-      @watcher.unsubscribe unless @watcher.nil?
-      @watcher = @zk.register(@discovery['path'], &watcher_callback)
+      @watcher = @zk.register(@discovery['path'], &watcher_callback) unless @watcher
 
       # Verify that we actually set up the watcher.
       unless @zk.exists?(@discovery['path'], :watch => true)
         log.error "synapse: zookeeper watcher path #{@discovery['path']} does not exist!"
-        raise RuntimeError.new('could not set a ZK watch on a node that should exist')
+        zk_cleanup
       end
       log.debug "synapse: set watch at #{@discovery['path']}"
     end
@@ -175,8 +179,9 @@ module Synapse
       port = decoded['port'] || (raise ValueError, 'instance json data does not have port key')
       name = decoded['name'] || nil
       weight = decoded['weight'] || nil
+      haproxy_server_options = decoded['haproxy_server_options'] || nil
 
-      return host, port, name, weight
+      return host, port, name, weight, haproxy_server_options
     end
   end
 end

data/lib/synapse/service_watcher/zookeeper_dns.rb

@@ -19,7 +19,7 @@ require 'thread'
 # for messages indicating that new servers are available, the check interval
 # has passed (triggering a re-resolve), or that the watcher should shut down.
 # The DNS watcher is responsible for the actual reconfiguring of backends.
-module Synapse
+class Synapse::ServiceWatcher
   class ZookeeperDnsWatcher < BaseWatcher
 
     # Valid messages that can be passed through the internal message queue
@@ -46,7 +46,7 @@ module Synapse
       CHECK_INTERVAL_MESSAGE = CheckInterval.new
     end
 
-    class Dns < Synapse::DnsWatcher
+    class Dns < Synapse::ServiceWatcher::DnsWatcher
 
       # Overrides the discovery_servers method on the parent class
       attr_accessor :discovery_servers
@@ -106,7 +106,7 @@ module Synapse
       end
     end
 
-    class Zookeeper < Synapse::ZookeeperWatcher
+    class Zookeeper < Synapse::ServiceWatcher::ZookeeperWatcher
       def initialize(opts={}, synapse, message_queue)
         super(opts, synapse)
 

data/lib/synapse/version.rb

@@ -1,3 +1,3 @@
 module Synapse
-  VERSION = "0.12.1"
+  VERSION = "0.12.2"
 end

data/spec/lib/synapse/file_output_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe Synapse::FileOutput do
+  subject { Synapse::FileOutput.new(config['file_output']) }
+
+  before(:example) do
+    FileUtils.mkdir_p(config['file_output']['output_directory'])
+  end
+
+  after(:example) do
+    FileUtils.rm_r(config['file_output']['output_directory'])
+  end
+
+  let(:mockwatcher_1) 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)
+    mockWatcher
+  end
+  let(:mockwatcher_2) do
+    mockWatcher = double(Synapse::ServiceWatcher)
+    allow(mockWatcher).to receive(:name).and_return('foobar_service')
+    backends = [{ 'host' => 'somehost', 'port' => 1234}]
+    allow(mockWatcher).to receive(:backends).and_return(backends)
+    mockWatcher
+  end
+
+  it 'updates the config' do
+    expect(subject).to receive(:write_backends_to_file)
+    subject.update_config([mockwatcher_1])
+  end
+
+  it 'manages correct files' do
+    subject.update_config([mockwatcher_1, mockwatcher_2])
+    FileUtils.cd(config['file_output']['output_directory']) do
+      expect(Dir.glob('*.json')).to eql(['example_service.json', 'foobar_service.json'])
+    end
+    # Should clean up after itself
+    subject.update_config([mockwatcher_1])
+    FileUtils.cd(config['file_output']['output_directory']) do
+      expect(Dir.glob('*.json')).to eql(['example_service.json'])
+    end
+    # Should clean up after itself
+    subject.update_config([])
+    FileUtils.cd(config['file_output']['output_directory']) do
+      expect(Dir.glob('*.json')).to eql([])
+    end
+  end
+
+  it 'writes correct content' do
+    subject.update_config([mockwatcher_1])
+    data_path = File.join(config['file_output']['output_directory'],
+                          "example_service.json")
+    old_backends = JSON.load(File.read(data_path))
+    expect(old_backends.length).to eql(1)
+    expect(old_backends.first['host']).to eql('somehost')
+    expect(old_backends.first['port']).to eql(5555)
+  end
+end

data/spec/lib/synapse/haproxy_spec.rb

@@ -8,7 +8,16 @@ describe Synapse::Haproxy do
   let(:mockwatcher) do
     mockWatcher = double(Synapse::ServiceWatcher)
     allow(mockWatcher).to receive(:name).and_return('example_service')
-    backends = [{ 'host' => 'somehost', 'port' => '5555'}]
+    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
+
+  let(:mockwatcher_with_server_options) do
+    mockWatcher = double(Synapse::ServiceWatcher)
+    allow(mockWatcher).to receive(:name).and_return('example_service')
+    backends = [{ 'host' => 'somehost', 'port' => 5555, 'haproxy_server_options' => 'backup'}]
     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
@@ -29,4 +38,8 @@ describe Synapse::Haproxy do
     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
 
+  it 'respects haproxy_server_options' do
+    mockConfig = []
+    expect(subject.generate_backend_stanza(mockwatcher_with_server_options, mockConfig)).to eql(["\nbackend example_service", [], ["\tserver somehost:5555 somehost:5555 cookie somehost:5555 check inter 2000 rise 3 fall 2 backup"]])
+  end
 end

data/spec/lib/synapse/service_watcher_base_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-class Synapse::BaseWatcher
+class Synapse::ServiceWatcher::BaseWatcher
   attr_reader :should_exit, :default_servers
 end
 
-describe Synapse::BaseWatcher do
+describe Synapse::ServiceWatcher::BaseWatcher do
   let(:mocksynapse) { double() }
-  subject { Synapse::BaseWatcher.new(args, mocksynapse) }
+  subject { Synapse::ServiceWatcher::BaseWatcher.new(args, mocksynapse) }
   let(:testargs) { { 'name' => 'foo', 'discovery' => { 'method' => 'base' }, 'haproxy' => {} }}
 
   def remove_arg(name)

data/spec/lib/synapse/service_watcher_docker_spec.rb

@@ -1,13 +1,14 @@
 require 'spec_helper'
+require 'synapse/service_watcher/docker'
 
-class Synapse::DockerWatcher
+class Synapse::ServiceWatcher::DockerWatcher
   attr_reader :check_interval, :watcher, :synapse
   attr_accessor :default_servers
 end
 
-describe Synapse::DockerWatcher do
+describe Synapse::ServiceWatcher::DockerWatcher do
   let(:mocksynapse) { double() }
-  subject { Synapse::DockerWatcher.new(testargs, mocksynapse) }
+  subject { Synapse::ServiceWatcher::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)
@@ -84,9 +85,9 @@ describe Synapse::DockerWatcher do
     it('has a sane uri') { subject.send(:containers); expect(Docker.url).to eql('http://server1.local:4243') }
 
     context 'old style port mappings' do
+      let(:docker_data) { [{"Ports" => "0.0.0.0:49153->6379/tcp, 0.0.0.0:49154->6390/tcp", "Image" => "mycool/image:tagname"}] }
       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 
+        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
@@ -106,6 +107,12 @@ describe Synapse::DockerWatcher 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
+
+      it 'filters out containers with unmapped ports' do
+        test_docker_data = docker_data + [{"Ports" => [{'PrivatePort' => 6379}], "Image" => "mycool/image:unmapped"}]
+        expect(Docker::Util).to receive(:parse_json).and_return(test_docker_data)
+        expect(subject.send(:containers)).to eql([{"name"=>"mainserver", "host"=>"server1.local", "port"=>"49153"}])
+      end
     end
 
     context 'filters out wrong images' do
@@ -117,4 +124,3 @@ describe Synapse::DockerWatcher do
     end
   end
 end
-

data/spec/lib/synapse/service_watcher_ec2tags_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
+require 'synapse/service_watcher/ec2tag'
 require 'logging'
 
-class Synapse::EC2Watcher
+class Synapse::ServiceWatcher::Ec2tagWatcher
   attr_reader   :synapse
   attr_accessor :default_servers, :ec2
 end
@@ -28,9 +29,9 @@ class FakeAWSInstance
   end
 end
 
-describe Synapse::EC2Watcher do
+describe Synapse::ServiceWatcher::Ec2tagWatcher do
   let(:mock_synapse) { double }
-  subject { Synapse::EC2Watcher.new(basic_config, mock_synapse) }
+  subject { Synapse::ServiceWatcher::Ec2tagWatcher.new(basic_config, mock_synapse) }
 
   let(:basic_config) do
     { 'name' => 'ec2tagtest',
@@ -86,24 +87,24 @@ describe Synapse::EC2Watcher do
     end
 
     context 'when missing arguments' do
-      it 'complains if aws_region is missing' do
+      it 'does not break if aws_region is missing' do
         expect {
-          Synapse::EC2Watcher.new(remove_discovery_arg('aws_region'), mock_synapse)
-        }.to raise_error(ArgumentError, /Missing aws_region/)
+          Synapse::ServiceWatcher::Ec2tagWatcher.new(remove_discovery_arg('aws_region'), mock_synapse)
+        }.not_to raise_error
       end
-      it 'complains if aws_access_key_id is missing' do
+      it 'does not break 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/)
+          Synapse::ServiceWatcher::Ec2tagWatcher.new(remove_discovery_arg('aws_access_key_id'), mock_synapse)
+        }.not_to raise_error
       end
-      it 'complains if aws_secret_access_key is missing' do
+      it 'does not break 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/)
+          Synapse::ServiceWatcher::Ec2tagWatcher.new(remove_discovery_arg('aws_secret_access_key'), mock_synapse)
+        }.not_to raise_error
       end
       it 'complains if server_port_override is missing' do
         expect {
-          Synapse::EC2Watcher.new(remove_haproxy_arg('server_port_override'), mock_synapse)
+          Synapse::ServiceWatcher::Ec2tagWatcher.new(remove_haproxy_arg('server_port_override'), mock_synapse)
         }.to raise_error(ArgumentError, /Missing server_port_override/)
       end
     end
@@ -111,7 +112,7 @@ describe Synapse::EC2Watcher do
     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)
+            Synapse::ServiceWatcher::Ec2tagWatcher.new(munge_haproxy_arg('server_port_override', '80deadbeef'), mock_synapse)
           }.to raise_error(ArgumentError, /Invalid server_port_override/)
       end
     end
@@ -121,6 +122,27 @@ describe Synapse::EC2Watcher do
     let(:instance1) { FakeAWSInstance.new }
     let(:instance2) { FakeAWSInstance.new }
 
+    context 'watch' do
+
+      it 'discovers instances, configures backends, then sleeps' do
+        fake_backends = [1,2,3]
+        expect(subject).to receive(:discover_instances).and_return(fake_backends)
+        expect(subject).to receive(:set_backends).with(fake_backends) { subject.stop }
+        expect(subject).to receive(:sleep_until_next_check)
+        subject.send(:watch)
+      end
+
+      it 'sleeps until next check if discover_instances fails' do
+        expect(subject).to receive(:discover_instances) do
+          subject.stop
+          raise "discover failed"
+        end
+        expect(subject).to receive(:sleep_until_next_check)
+        subject.send(:watch)
+      end
+
+    end
+
     context 'using the AWS API' do
       let(:ec2_client) { double('AWS::EC2') }
       let(:instance_collection) { double('AWS::EC2::InstanceCollection') }