synapse 0.9.1 → 0.10.0

data/README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://travis-ci.org/airbnb/synapse.png?branch=master)](https://travis-ci.org/airbnb/synapse)
+[![Inline docs](http://inch-pages.github.io/github/airbnb/synapse.png)](http://inch-pages.github.io/github/airbnb/synapse)
 
 # Synapse #
 
@@ -20,7 +21,7 @@ One solution to this problem is a discovery service, like [Apache Zookeeper](htt
 However, Zookeeper and similar services have their own problems:
 
 * Service discovery is embedded in all of your apps; often, integration is not simple
-* The discovery layer itself it subject to failure
+* The discovery layer itself is subject to failure
 * Requires additional servers/instances
 
 Synapse solves these difficulties in a simple and fault-tolerant way.
@@ -39,7 +40,7 @@ It is easy to write your own watchers for your use case, and we encourage submit
 
 ## Example Migration ##
 
-Lets suppose your rails application depends on a Postgre database instance.
+Let's suppose your rails application depends on a Postgres database instance.
 The database.yaml file has the DB host and port hardcoded:
 
 ```yaml
@@ -126,8 +127,9 @@ The name is just a human-readable string; it will be used in logs and notificati
 Each value in the services hash is also a hash, and should contain the following keys:
 
 * `discovery`: how synapse will discover hosts providing this service (see below)
-* `default_servers`: the list of default servers providing this service; synapse uses these if none others can be discovered
+* `default_servers`: the list of default servers providing this service; synapse uses these if no others can be discovered
 * `haproxy`: how will the haproxy section for this service be configured
+* `shared_frontend`: optional: haproxy configuration directives for a shared http frontend (see below)
 
 #### Service Discovery ####
 
@@ -136,7 +138,7 @@ Put these into the `discovery` section of the service hash, with these options:
 
 ##### Stub #####
 
-The stub watcher, this is useful in situations where you only want to use the servers in the `default_servers` list.
+The stub watcher is useful in situations where you only want to use the servers in the `default_servers` list.
 It has only one option:
 
 * `method`: stub
@@ -156,7 +158,7 @@ We assume that the data contains a hostname and a port for service servers.
 
 ##### Docker #####
 
-This watcher retrieves a list of [docker](http://www.docker.io/) containers via docker's [HTTP API](http://docs.docker.io/en/latest/api/docker_remote_api/).
+This watcher retrieves a list of [docker](http://www.docker.io/) containers via docker's [HTTP API](http://docs.docker.io/en/latest/reference/api/docker_remote_api/).
 It takes the following options:
 
 * `method`: docker
@@ -176,11 +178,13 @@ Each hash in that section has the following options:
 
 The `default_servers` list is used only when service discovery returns no servers.
 In that case, the service proxy will be created with the servers listed here.
-If you do not list any default servers, no proxy will be created.
+If you do not list any default servers, no proxy will be created.  The
+`default_servers` will also be used in addition to discovered servers if the
+`keep_default_servers` option is set.
 
 #### The `haproxy` Section ####
 
-This section is it's own hash, which should contain the following keys:
+This section is its own hash, which should contain the following keys:
 
 * `port`: the port (on localhost) where HAProxy will listen for connections to the service.
 * `server_port_override`: the port that discovered servers listen on; you should specify this if your discovery mechanism only discovers names or addresses (like the DNS watcher). If the discovery method discovers a port along with hostnames (like the zookeeper watcher) this option may be left out, but will be used in preference if given.
@@ -199,10 +203,101 @@ The `haproxy` section of the config file has the following options:
 * `do_reloads`: whether or not Synapse will reload HAProxy (default to `true`)
 * `global`: options listed here will be written into the `global` section of the HAProxy config
 * `defaults`: options listed here will be written into the `defaults` section of the HAProxy config
-* `bind_address`: force HAProxy to listen  on this address (default is localhost)
+* `bind_address`: force HAProxy to listen on this address (default is localhost)
+* `shared_fronted`: (OPTIONAL) additional lines passed to the HAProxy config used to configure a shared HTTP frontend (see below)
 
 Note that a non-default `bind_address` can be dangerous: it is up to you to ensure that HAProxy will not attempt to bind an address:port combination that is not already in use by one of your services.
 
+### HAProxy shared HTTP Frontend ###
+
+For HTTP-only services, it is not always necessary or desirable to dedicate a TCP port per service, since HAProxy can route traffic based on host headers.
+To support this, the optional `shared_fronted` section can be added to both the `haproxy` section and each indvidual service definition: synapse will concatenate them all into a single frontend section in the generated haproxy.cfg file.
+Note that synapse does not assemble the routing ACLs for you: you have to do that yourself based on your needs.
+This is probably most useful in combination with the `service_conf_dir` directive in a case where the individual service config files are being distributed by a configuration manager such as puppet or chef, or bundled into service packages.
+For example:
+
+```yaml
+{
+  "haproxy": {
+    "shared_frontend": [
+      "bind 127.0.0.1:8081"
+    ],
+    "reload_command": "service haproxy reload",
+    "config_file_path": "/etc/haproxy/haproxy.cfg",
+    "socket_file_path": "/var/run/haproxy.sock",
+    "global": [
+      "daemon",
+      "user    haproxy",
+      "group   haproxy",
+      "maxconn 4096",
+      "log     127.0.0.1 local2 notice",
+      "stats   socket /var/run/haproxy.sock"
+    ],
+    "defaults": [
+      "log      global",
+      "balance  roundrobin"
+    ]
+  },
+  "services": {
+    "service1": {
+      "discovery": {
+        "method": "zookeeper",
+        "path":  "/nerve/services/service1",
+        "hosts": [ "0.zookeeper.example.com:2181" ]
+      },
+      "haproxy": {
+        "server_options": "check inter 2s rise 3 fall 2",
+        "shared_frontend": [
+          "acl is_service1 hdr_dom(host) -i service1.lb.example.com",
+          "use_backend service1 if is_service1"
+        ],
+        "backend": [
+          "mode http"
+        ]
+      }
+    },
+    "service2": {
+      "discovery": {
+        "method": "zookeeper",
+        "path":  "/nerve/services/service2",
+        "hosts": [ "0.zookeeper.example.com:2181" ]
+      },
+      "haproxy": {
+        "server_options": "check inter 2s rise 3 fall 2",
+        "shared_frontend": [
+          "acl is_service1 hdr_dom(host) -i service2.lb.example.com",
+          "use_backend service2 if is_service2"
+        ],
+        "backend": [
+          "mode http"
+        ]
+      }
+    }
+  }
+}
+```
+
+This would produce an haproxy.cfg much like the following:
+
+```
+backend service1
+        mode http
+        server server1.example.net:80 server1.example.net:80 check inter 2s rise 3 fall 2
+
+backend service2
+        mode http
+        server server2.example.net:80 server2.example.net:80 check inter 2s rise 3 fall 2
+
+frontend shared-frontend
+        bind 127.0.0.1:8081
+        acl is_service1 hdr_dom(host) -i service1.lb
+        use_backend service1 if is_service1
+        acl is_service2 hdr_dom(host) -i service2.lb
+        use_backend service2 if is_service2
+```
+
+Non-HTTP backends such as MySQL or RabbitMQ will obviously continue to need their own dedicated ports.
+
 ## Contributing
 
 1. Fork it

data/bin/synapse

@@ -37,7 +37,7 @@ def parseconfig(filename)
     raise ArgumentError, "config file does not exist:\n#{e.inspect}"
   rescue Errno::EACCES => e
     raise ArgumentError, "could not open config file:\n#{e.inspect}"
-  rescue YAML::ParseError => e
+  rescue YAML::SyntaxError => e
     raise "config file #{filename} is not yaml:\n#{e.inspect}"
   end
   return c.to_ruby

data/lib/synapse/haproxy.rb

@@ -543,18 +543,35 @@ module Synapse
     # generates a new config based on the state of the watchers
     def generate_config(watchers)
       new_config = generate_base_config
+      shared_frontend_lines = generate_shared_frontend
 
       watchers.each do |watcher|
         @watcher_configs[watcher.name] ||= parse_watcher_config(watcher)
-
         new_config << generate_frontend_stanza(watcher, @watcher_configs[watcher.name]['frontend'])
         new_config << generate_backend_stanza(watcher, @watcher_configs[watcher.name]['backend'])
+        if watcher.haproxy.include?('shared_frontend')
+          if @opts['shared_frontend'] == nil
+            log.warn "synapse: service #{watcher.name} contains a shared frontend section but the base config does not! skipping."
+          else
+            shared_frontend_lines << validate_haproxy_stanza(watcher.haproxy['shared_frontend'].map{|l| "\t#{l}"}, "frontend", "shared frontend section for #{watcher.name}")
+          end
+        end
       end
+      new_config << shared_frontend_lines.flatten if shared_frontend_lines
 
       log.debug "synapse: new haproxy config: #{new_config}"
       return new_config.flatten.join("\n")
     end
 
+    # pull out the shared frontend section if any
+    def generate_shared_frontend
+      return nil unless @opts.include?('shared_frontend')
+      log.debug "synapse: found a shared frontend section"
+      shared_frontend_lines = ["\nfrontend shared-frontend"]
+      shared_frontend_lines << validate_haproxy_stanza(@opts['shared_frontend'].map{|l| "\t#{l}"}, "frontend", "shared frontend")
+      return shared_frontend_lines
+    end
+
     # generates the global and defaults sections of the config file
     def generate_base_config
       base_config = ["# auto-generated by synapse at #{Time.now}\n"]
@@ -593,20 +610,24 @@ module Synapse
           })
 
         # pick only those fields that are valid and warn about the invalid ones
-        config[section].select!{|setting|
-          parsed_setting = setting.strip.gsub(/\s+/, ' ').downcase
-          if @@section_fields[section].any? {|field| parsed_setting.start_with?(field)}
-            true
-          else
-            log.warn "synapse: service #{watcher.name} contains invalid #{section} setting: '#{setting}'"
-            false
-          end
-        }
+        config[section] = validate_haproxy_stanza(config[section], section, watcher.name)
       end
 
       return config
     end
 
+    def validate_haproxy_stanza(stanza, stanza_type, service_name)
+      return stanza.select {|setting|
+        parsed_setting = setting.strip.gsub(/\s+/, ' ').downcase
+        if @@section_fields[stanza_type].any? {|field| parsed_setting.start_with?(field)}
+          true
+        else
+          log.warn "synapse: service #{service_name} contains invalid #{stanza_type} setting: '#{setting}', discarding"
+          false
+        end
+      }
+    end
+
     # generates an individual stanza for a particular watcher
     def generate_frontend_stanza(watcher, config)
       unless watcher.haproxy.has_key?("port")
@@ -642,7 +663,7 @@ module Synapse
       # first, get a list of existing servers for various backends
       begin
         s = UNIXSocket.new(@opts['socket_file_path'])
-        s.write('show stat;')
+        s.write("show stat\n")
         info = s.read()
       rescue StandardError => e
         log.warn "synapse: unhandled error reading stats socket: #{e.inspect}"
@@ -690,9 +711,9 @@ module Synapse
       cur_backends.each do |section, backends|
         backends.each do |backend|
           if enabled_backends[section].include? backend
-            command = "enable server #{section}/#{backend};"
+            command = "enable server #{section}/#{backend}\n"
           else
-            command = "disable server #{section}/#{backend};"
+            command = "disable server #{section}/#{backend}\n"
           end
 
           # actually write the command to the socket
@@ -713,6 +734,8 @@ module Synapse
           end
         end
       end
+
+      log.info "synapse: reconfigured haproxy"
     end
 
     # writes the config
@@ -741,6 +764,7 @@ module Synapse
       # do the actual restart
       res = `#{opts['reload_command']}`.chomp
       raise "failed to reload haproxy via #{opts['reload_command']}: #{res}" unless $?.success?
+      log.info "synapse: restarted haproxy"
 
       @last_restart = Time.now()
       @restart_required = false

data/lib/synapse/service_watcher.rb

@@ -3,16 +3,18 @@ require "synapse/service_watcher/zookeeper"
 require "synapse/service_watcher/ec2tag"
 require "synapse/service_watcher/dns"
 require "synapse/service_watcher/docker"
+require "synapse/service_watcher/zookeeper_dns"
 
 module Synapse
   class ServiceWatcher
 
     @watchers = {
-      'base'=>BaseWatcher,
-      'zookeeper'=>ZookeeperWatcher,
-      'ec2tag'=>EC2Watcher,
+      'base' => BaseWatcher,
+      'zookeeper' => ZookeeperWatcher,
+      'ec2tag' => EC2Watcher,
       'dns' => DnsWatcher,
-      'docker' => DockerWatcher
+      'docker' => DockerWatcher,
+      'zookeeper_dns' => ZookeeperDnsWatcher,
     }
 
     # the method which actually dispatches watcher creation requests

data/lib/synapse/service_watcher/base.rb

@@ -40,6 +40,8 @@ module Synapse
       @default_servers = opts['default_servers'] || []
       @backends = @default_servers
 
+      @keep_default_servers = opts['keep_default_servers'] || false
+
       # set a flag used to tell the watchers to exit
       # this is not used in every watcher
       @should_exit = false
@@ -91,5 +93,17 @@ module Synapse
 
       log.warn "synapse: warning: a stub watcher with no default servers is pretty useless" if @default_servers.empty?
     end
+
+    def set_backends(new_backends)
+      if @keep_default_servers
+        @backends = @default_servers + new_backends
+      else
+        @backends = new_backends
+      end
+    end
+
+    def reconfigure!
+      @synapse.reconfigure!
+    end
   end
 end

data/lib/synapse/service_watcher/dns.rb

@@ -15,7 +15,11 @@ module Synapse
     end
 
     def ping?
-      !(resolver.getaddresses('airbnb.com').empty?)
+      @watcher.alive? && !(resolver.getaddresses('airbnb.com').empty?)
+    end
+
+    def discovery_servers
+      @discovery['servers']
     end
 
     private
@@ -23,7 +27,7 @@ module Synapse
       raise ArgumentError, "invalid discovery method #{@discovery['method']}" \
         unless @discovery['method'] == 'dns'
       raise ArgumentError, "a non-empty list of servers is required" \
-        if @discovery['servers'].empty?
+        if discovery_servers.empty?
     end
 
     def watch
@@ -57,7 +61,7 @@ module Synapse
 
     def resolve_servers
       resolver.tap do |dns|
-        resolution = @discovery['servers'].map do |server|
+        resolution = discovery_servers.map do |server|
           addresses = dns.getaddresses(server['host']).map(&:to_s)
           [server, addresses.sort]
         end
@@ -79,7 +83,8 @@ module Synapse
         addresses.map do |address|
           {
             'host' => address,
-            'port' => server['port']
+            'port' => server['port'],
+            'name' => server['name'],
           }
         end
       end
@@ -95,9 +100,10 @@ module Synapse
         end
       else
         log.info "synapse: discovered #{new_backends.length} backends for service #{@name}"
-        @backends = new_backends
+        set_backends(new_backends)
       end
-      @synapse.reconfigure!
+
+      reconfigure!
     end
   end
 end

data/lib/synapse/service_watcher/docker.rb

@@ -111,9 +111,9 @@ module Synapse
         end
       else
         log.info "synapse: discovered #{new_backends.length} backends for service #{@name}"
-        @backends = new_backends
+        set_backends(new_backends)
       end
-      @synapse.reconfigure!
+      reconfigure!
     end
 
   end

data/lib/synapse/service_watcher/zookeeper.rb

@@ -88,7 +88,7 @@ module Synapse
         end
       else
         log.info "synapse: discovered #{new_backends.length} backends for service #{@name}"
-        @backends = new_backends
+        set_backends(new_backends)
       end
     end
 
@@ -108,7 +108,7 @@ module Synapse
         # Rediscover
         discover
         # send a message to calling class to reconfigure
-        @synapse.reconfigure!
+        reconfigure!
       end
     end
 

data/lib/synapse/service_watcher/zookeeper_dns.rb

@@ -0,0 +1,232 @@
+require 'synapse/service_watcher/base'
+require 'synapse/service_watcher/dns'
+require 'synapse/service_watcher/zookeeper'
+
+require 'thread'
+
+# Watcher for watching Zookeeper for entries containing DNS names that are
+# continuously resolved to IP Addresses.  The use case for this watcher is to
+# allow services that are addressed by DNS to be reconfigured via Zookeeper
+# instead of an update of the synapse config.
+#
+# The implementation builds on top of the existing DNS and Zookeeper watchers.
+# This watcher creates a thread to manage the lifecycle of the DNS and
+# Zookeeper watchers.  This thread also publishes messages on a queue to
+# indicate that DNS should be re-resolved (after the check interval) or that
+# the DNS watcher should be shut down.  The Zookeeper watcher waits for changes
+# in backends from zookeeper and publishes those changes on an internal queue
+# consumed by the DNS watcher.  The DNS watcher blocks on this queue waiting
+# 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 ZookeeperDnsWatcher < BaseWatcher
+
+    # Valid messages that can be passed through the internal message queue
+    module Messages
+      class InvalidMessageError < RuntimeError; end
+
+      # Indicates new servers identified by DNS names to be resolved.  This is
+      # sent from Zookeeper on events that modify the ZK node. The payload is
+      # an array of hashes containing {'host', 'port', 'name'}
+      class NewServers < Struct.new(:servers); end
+
+      # Indicates that DNS should be re-resolved.  This is sent by the
+      # ZookeeperDnsWatcher thread every check_interval seconds to cause a
+      # refresh of the IP addresses.
+      class CheckInterval; end
+
+      # Indicates that the DNS watcher should shut down.  This is sent when
+      # stop is called.
+      class StopWatcher; end
+
+      # Saved instances of message types with contents that cannot vary.  This
+      # reduces object allocation.
+      STOP_WATCHER_MESSAGE = StopWatcher.new
+      CHECK_INTERVAL_MESSAGE = CheckInterval.new
+    end
+
+    class Dns < Synapse::DnsWatcher
+
+      # Overrides the discovery_servers method on the parent class
+      attr_accessor :discovery_servers
+
+      def initialize(opts={}, synapse, message_queue)
+        @message_queue = message_queue
+
+        super(opts, synapse)
+      end
+
+      def stop
+        @message_queue.push(Messages::STOP_WATCHER_MESSAGE)
+      end
+
+      def watch
+        last_resolution = nil
+        while true
+          # Blocks on message queue, the message will be a signal to stop
+          # watching, to check a new set of servers from ZK, or to re-resolve
+          # the DNS (triggered every check_interval seconds)
+          message = @message_queue.pop
+
+          log.debug "synapse: received message #{message.inspect}"
+
+          case message
+          when Messages::StopWatcher
+            break
+          when Messages::NewServers
+            self.discovery_servers = message.servers
+          when Messages::CheckInterval
+            # Proceed to re-resolve the DNS
+          else
+            raise Messages::InvalidMessageError,
+              "Received unrecognized message: #{message.inspect}"
+          end
+
+          # Empty servers means we haven't heard back from ZK yet or ZK is
+          # empty.  This should only occur if we don't get results from ZK
+          # within check_interval seconds or if ZK is empty.
+          if self.discovery_servers.nil? || self.discovery_servers.empty?
+            log.warn "synapse: no backends for service #{@name}"
+          else
+            # Resolve DNS names with the nameserver
+            current_resolution = resolve_servers
+            unless last_resolution == current_resolution
+              last_resolution = current_resolution
+              configure_backends(last_resolution)
+            end
+          end
+        end
+      end
+
+      private
+
+      # Validation is skipped as it has already occurred in the parent watcher
+      def validate_discovery_opts
+      end
+    end
+
+    class Zookeeper < Synapse::ZookeeperWatcher
+      def initialize(opts={}, synapse, message_queue)
+        super(opts, synapse)
+
+        @message_queue = message_queue
+      end
+
+      # Overrides reconfigure! to cause the new list of servers to be messaged
+      # to the DNS watcher rather than invoking a synapse reconfigure directly
+      def reconfigure!
+        # push the new backends onto the queue
+        @message_queue.push(Messages::NewServers.new(@backends))
+      end
+
+      private
+
+      # Validation is skipped as it has already occurred in the parent watcher
+      def validate_discovery_opts
+      end
+    end
+
+    def start
+      dns_discovery_opts = @discovery.select do |k,_|
+        k == 'nameserver'
+      end
+
+      zookeeper_discovery_opts = @discovery.select do |k,_|
+        k == 'hosts' || k == 'path'
+      end
+
+      @check_interval = @discovery['check_interval'] || 30.0
+
+      @message_queue = Queue.new
+
+      @dns = Dns.new(
+        mk_child_watcher_opts(dns_discovery_opts),
+        @synapse,
+        @message_queue
+      )
+
+      @zk = Zookeeper.new(
+        mk_child_watcher_opts(zookeeper_discovery_opts),
+        @synapse,
+        @message_queue
+      )
+
+      @zk.start
+      @dns.start
+
+      @watcher = Thread.new do
+        until @should_exit
+          # Trigger a DNS resolve every @check_interval seconds
+          sleep @check_interval
+
+          # Only trigger the resolve if the queue is empty, every other message
+          # on the queue would either cause a resolve or stop the watcher
+          if @message_queue.empty?
+            @message_queue.push(Messages::CHECK_INTERVAL_MESSAGE)
+          end
+
+        end
+        log.info "synapse: zookeeper_dns watcher exited successfully"
+      end
+    end
+
+    def ping?
+      @watcher.alive? && @dns.ping? && @zk.ping?
+    end
+
+    def stop
+      super
+
+      @dns.stop
+      @zk.stop
+    end
+
+    def backends
+      @dns.backends
+    end
+
+    private
+
+    def validate_discovery_opts
+      unless @discovery['method'] == 'zookeeper_dns'
+        raise ArgumentError, "invalid discovery method #{@discovery['method']}"
+      end
+
+      unless @discovery['hosts']
+        raise ArgumentError, "missing or invalid zookeeper host for service #{@name}"
+      end
+
+      unless @discovery['path']
+        raise ArgumentError, "invalid zookeeper path for service #{@name}"
+      end
+    end
+
+    # Method to generate a full config for the children (Dns and Zookeeper)
+    # watchers
+    #
+    # Notes on passing in the default_servers:
+    #
+    #   Setting the default_servers here allows the Zookeeper watcher to return
+    #   a list of backends based on the default servers when it fails to find
+    #   any matching servers.  These are passed on as the discovered backends
+    #   to the DNS watcher, which will then watch them as normal for DNS
+    #   changes.  The default servers can also come into play if none of the
+    #   hostnames from Zookeeper resolve to addresses in the DNS watcher.  This
+    #   should generally result in the expected behavior, but caution should be
+    #   taken when deciding that this is the desired behavior.
+    def mk_child_watcher_opts(discovery_opts)
+      {
+        'name' => @name,
+        'haproxy' => @haproxy,
+        'discovery' => discovery_opts,
+        'default_servers' => @default_servers,
+      }
+    end
+
+    # Override reconfigure! as this class should not explicitly reconfigure
+    # synapse
+    def reconfigure!
+    end
+  end
+end

data/lib/synapse/version.rb

@@ -1,3 +1,3 @@
 module Synapse
-  VERSION = "0.9.1"
+  VERSION = "0.10.0"
 end

data/spec/lib/synapse/service_watcher_base_spec.rb

@@ -41,6 +41,15 @@ describe Synapse::BaseWatcher 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/spec_helper.rb

@@ -6,13 +6,13 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 require "#{File.dirname(__FILE__)}/../lib/synapse"
 require 'pry'
-require 'support/config'
+require 'support/configuration'
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
-  config.include Config
+  config.include Configuration
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing

data/spec/support/{config.rb → configuration.rb}

@@ -1,6 +1,6 @@
 require "yaml"
 
-module Config
+module Configuration
 
   def config
     @config ||= YAML::load_file(File.join(File.dirname(File.expand_path(__FILE__)), 'minimum.conf.yaml'))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: synapse
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-18 00:00:00.000000000 Z
+date: 2014-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zk
@@ -141,12 +141,13 @@ files:
 - lib/synapse/service_watcher/docker.rb
 - lib/synapse/service_watcher/ec2tag.rb
 - lib/synapse/service_watcher/zookeeper.rb
+- lib/synapse/service_watcher/zookeeper_dns.rb
 - lib/synapse/version.rb
 - spec/lib/synapse/haproxy_spec.rb
 - spec/lib/synapse/service_watcher_base_spec.rb
 - spec/lib/synapse/service_watcher_docker_spec.rb
 - spec/spec_helper.rb
-- spec/support/config.rb
+- spec/support/configuration.rb
 - spec/support/minimum.conf.yaml
 - synapse.gemspec
 homepage: ''
@@ -163,7 +164,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 575568743231626432
+      hash: 2945433216079037469
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -172,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 575568743231626432
+      hash: 2945433216079037469
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -184,5 +185,5 @@ test_files:
 - spec/lib/synapse/service_watcher_base_spec.rb
 - spec/lib/synapse/service_watcher_docker_spec.rb
 - spec/spec_helper.rb
-- spec/support/config.rb
+- spec/support/configuration.rb
 - spec/support/minimum.conf.yaml