synapse 0.13.8 → 0.14.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDAyZjEyZDU5ZGUwMmMwOTFkNjgyMmUwMmU2NGRlYTBmMWQ5MmE3YQ==
+    YTEwNDE5ZTdlZDM4Njk2YmJkMDRjYWQzYTNiM2FkZTM0MzgyZWE4YQ==
   data.tar.gz: !binary |-
-    YzNjYjQ2NWJkNDAyYzllZmE0ZGJjNWFmZmQ5YTdmMWU2NjlhYjQ4Mg==
+    ZjBmNmVmOTY2YWRiYTY1NWZmYTg3YjhiMThhY2NmNjIxNmE3ODkwYQ==
 SHA512:
   metadata.gz: !binary |-
-    NGE5ZjEwYmM0MmE2MjgyYjY5YTQzN2Q3YjY0YzliMjFjNmYwNWUwMDAyN2M5
-    ZTg2MmQ0ZWNlNTM2OTQyZjk4MWMzN2EzMGNiNjM1ZGE4MjE2OGQ3OTRiZjMx
-    M2U2NmNmZDkyODQxMDI4NjYwNmI3NmYzY2M2ZGM1NzFhMmVkZTQ=
+    NjhlNDA1YjY1ODkxZWU4YzMyMzI2ODE1YWNjMzlmZWM4MTk1OTVjZTVkMjc4
+    ODFjMTVlNDEyYjVmMDk0YTAxMjM0MWMyNGRmOGFiYjdhNDM4OWFiNDFlMjE1
+    ZDMzNzZiYjg2MjgzY2VmYjQ2YjAxOGEwOTE0Y2MwMTkwNGFjMmU=
   data.tar.gz: !binary |-
-    MzAxZGIyYTRiNDdlYjYwYzY1NzM0ZDlhMTllNmNkYjdiYzQzODFlOGFmYmJi
-    NTQ1MmIzOTI3Y2IxZmQyZTYwYzNiMDRiMTM3ZGZmOTc1OTAzMmQyZWEzYTY5
-    MmE1NDQ3NDUxZGI3MGE3NGVhZDdiODE1NzA2NTk5ZjFlNmI0NGY=
+    MGI0ZTBjNGQ5NjA0NmU1OWI0NzJhYmYyNDI2NWEyODI0MjA1NDM5NmYxNzEw
+    YWYxMzI3MDc2ZTEyMDFkM2U5MzkyY2U5NzBkNjQ4YjA4YWNhNTI0YmRlMzlj
+    N2JhM2MxYjQ5YWVhMzBlZWFhZTM3Y2RkMzVhOTNlMzc0ZmVkY2Y=

data/.travis.yml

@@ -2,7 +2,8 @@ language: ruby
 cache: bundler
 sudo: false
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.6
-  - 2.2.2
+  - 1.9.3-p551
+  - 2.0.0-p648
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1

data/README.md

@@ -134,12 +134,24 @@ The file has three main sections.
 
 The `services` section is a hash, where the keys are the `name` of the service to be configured.
 The name is just a human-readable string; it will be used in logs and notifications.
-Each value in the services hash is also a hash, and should contain the following keys:
+Each value in the services hash is also a hash, and must contain the following keys:
+
+* [`discovery`](#discovery): how synapse will discover hosts providing this service (see [below](#discovery))
+
+The services hash *should* contain a section on how to configure the routing
+component you wish to use for this particular service. The only choice currently
+is `haproxy`:
 
-* [`discovery`](#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 no others can be discovered
 * [`haproxy`](#haproxysvc): how will the haproxy section for this service be configured
 
+The services hash may contain the following keys:
+
+* `default_servers` (default: `[]`): the list of default servers providing this service; synapse uses these if no others can be discovered. See [Listing Default Servers](#defaultservers).
+* `keep_default_servers` (default: false): whether default servers should be added to discovered services
+* `use_previous_backends` (default: true): if at any time the registry drops all backends, use previous backends we already know about.
+<a name="backend_port_override"/>
+* `backend_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 or the Ec2TagWatcher). 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.
+
 <a name="discovery"/>
 #### Service Discovery ####
 
@@ -214,9 +226,9 @@ It takes the following options:
   this is case-sensitive.
 * `tag_value`: the value to match on. Case-sensitive.
 
-Additionally, you MUST supply `server_port_override` in the `haproxy`
-section of the configuration as this watcher does not know which port
-the backend service is listening on.
+Additionally, you MUST supply [`backend_port_override`](#backend_port_override)
+in the service configuration as this watcher does not know which port the
+backend service is listening on.
 
 The following options are optional, provided the well-known `AWS_`
 environment variables shown are set. If supplied, these options will
@@ -238,6 +250,7 @@ It takes the following options:
 * `check_interval`: How often to request the list of tasks from Marathon (default: 10 seconds)
 * `port_index`: Index of the backend port in the task's "ports" array. (default: 0)
 
+<a name="defaultservers"/>
 #### Listing Default Servers ####
 
 You may list a number of default servers providing a service.
@@ -262,9 +275,13 @@ by unsetting `use_previous_backends`.
 
 This section is its own hash, which should contain the following keys:
 
+* `disabled`: A boolean value indicating if haproxy configuration management
+for just this service instance ought be disabled. For example, if you want
+file output for a particular service but no HAProxy config. (default is ``False``)
 * `port`: the port (on localhost) where HAProxy will listen for connections to the service. If this is omitted, only a backend stanza (and no frontend stanza) will be generated for this service; you'll need to get traffic to your service yourself via the `shared_frontend` or manual frontends in `extra_sections`
 * `bind_address`: force HAProxy to listen on this address ( default is localhost ). Setting `bind_address` on a per service basis overrides the global `bind_address` in the top level `haproxy`. Having HAProxy listen for connections on different addresses ( example: service1 listen on 127.0.0.2:443 and service2 listen on 127.0.0.3:443) allows /etc/hosts entries to point to services.
-* `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.
+* `bind_options`: optional: default value is an empty string, specify additional bind parameters, such as ssl accept-proxy, crt, ciphers etc.
+* `server_port_override`: **DEPRECATED**. Renamed [`backend_port_override`](#backend_port_override) and moved to the top level hash. This will be removed in future versions.
 * `server_options`: the haproxy options for each `server` line of the service in HAProxy config; it may be left out.
 * `frontend`: additional lines passed to the HAProxy config in the `frontend` stanza of this service
 * `backend`: additional lines passed to the HAProxy config in the `backend` stanza of this service
@@ -371,7 +388,7 @@ For example:
     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
+     - "use_backend service2 if is_service2"
     backend:
      - "mode http"
 
@@ -410,3 +427,8 @@ Non-HTTP backends such as MySQL or RabbitMQ will obviously continue to need thei
 
 See the Service Watcher [README](lib/synapse/service_watcher/README.md) for
 how to add new Service Watchers.
+
+### Creating a Config Generator ###
+
+See the Config Generator [README](lib/synapse/config_generator/README.md) for
+how to add new Config Generators

data/config/synapse.conf.json

@@ -18,6 +18,7 @@
       "haproxy": {
         "port": 3213,
         "server_options": "check inter 2s rise 3 fall 2",
+        "bind_options": "ssl no-sslv3 crt /path/to/cert/example.pem ciphers ECDHE-ECDSA-CHACHA20-POLY1305",
         "listen": [
           "mode http",
           "option httpchk /health",

data/lib/synapse.rb

@@ -1,11 +1,10 @@
 require 'logger'
 require 'json'
 
-require "synapse/version"
-require "synapse/log"
-require "synapse/haproxy"
-require "synapse/file_output"
-require "synapse/service_watcher"
+require 'synapse/version'
+require 'synapse/log'
+require 'synapse/config_generator'
+require 'synapse/service_watcher'
 
 
 module Synapse
@@ -14,22 +13,14 @@ module Synapse
     include Logging
 
     def initialize(opts={})
+      # create objects that need to be notified of service changes
+      @config_generators = create_config_generators(opts)
+      raise "no config generators supplied" if @config_generators.empty?
+
       # create the service watchers for all our services
       raise "specify a list of services to connect in the config" unless opts.has_key?('services')
       @service_watchers = create_service_watchers(opts['services'])
 
-      # create objects that need to be notified of service changes
-      @config_generators = []
-      # create the haproxy config generator, this is mandatory
-      raise "haproxy config section is missing" unless opts.has_key?('haproxy')
-      @config_generators << Haproxy.new(opts['haproxy'])
-
-      # possibly create a file manifestation for services that do not
-      # want to communicate via haproxy, e.g. cassandra
-      if opts.has_key?('file_output')
-        @config_generators << FileOutput.new(opts['file_output'])
-      end
-
       # configuration is initially enabled to configure on first loop
       @config_updated = true
 
@@ -85,9 +76,13 @@ module Synapse
       @config_updated = true
     end
 
+    def available_generators
+      Hash[@config_generators.collect{|cg| [cg.name, cg]}]
+    end
+
     private
     def create_service_watchers(services={})
-      service_watchers =[]
+      service_watchers = []
       services.each do |service_name, service_config|
         service_watchers << ServiceWatcher.create(service_name, service_config, self)
       end
@@ -95,5 +90,16 @@ module Synapse
       return service_watchers
     end
 
+    private
+    def create_config_generators(opts={})
+      config_generators = []
+      opts.each do |type, generator_opts|
+        # Skip the "services" top level key
+        next if type == 'services'
+        config_generators << ConfigGenerator.create(type, generator_opts)
+      end
+
+      return config_generators
+    end
   end
 end

data/lib/synapse/config_generator.rb

@@ -0,0 +1,20 @@
+require 'synapse/log'
+require 'synapse/config_generator/base'
+
+module Synapse
+  class ConfigGenerator
+    # the type which actually dispatches generator creation requests
+    def self.create(type, opts)
+      generator = begin
+        type = type.downcase
+        require "synapse/config_generator/#{type}"
+        # haproxy => Haproxy, file_output => FileOutput, etc ...
+        type_class  = type.split('_').map{|x| x.capitalize}.join
+        self.const_get("#{type_class}")
+      rescue Exception => e
+        raise ArgumentError, "Specified a config generator of #{type}, which could not be found: #{e}"
+      end
+      return generator.new(opts)
+    end
+  end
+end

data/lib/synapse/config_generator/README.md

@@ -0,0 +1,74 @@
+## ConfigGenerator Classes
+
+Generators are the piece of Synapse that react to changes in service
+registrations and actually reflect those changes in local state.
+Generators should conform to the interface specified by `BaseGenerator` and
+when your generator has received an update from synapse via `update_config` it
+should sync the watcher state with the external configuration (e.g. HAProxy
+state)
+
+```ruby
+require "synapse/config_generator/base"
+
+class Synapse::ConfigGenerator
+  class MyGenerator < BaseGenerator
+    # The generator name is used to find service specific
+    # configuration in the service watchers. When supplying
+    # per service config, use this as the key
+    NAME = 'my_generator'.freeze
+
+    def initialize(opts = {})
+        # Process and validate any options specified in the dedicated section
+        # for this config generator, given as the `opts` hash. You may omit
+        # this method, or you can declare your own, but remember to invoke
+        # the parent initializer
+        super(opts)
+    end
+
+    def update_config(watchers)
+      # synapse will call this method whenever watcher state changes with the
+      # watcher state. You should reflect that state in the local config state
+    end
+
+    def tick
+      # Called every loop of the main Synapse loop regardless of watcher
+      # changes (roughly ~1s). You can use this to rate limit how often your
+      # config generator actually reconfigures external services (e.g. HAProxy
+      # may need to rate limit reloads as those can be disruptive to in
+      # flight connections
+    end
+
+    def normalize_watcher_provided_config(service_watcher_name, service_watcher_config)
+      # Every service watcher section of the Synapse configuration can contain
+      # options that change how the config generators react for that
+      # particular service. This normalize method is a good place to ensure
+      # you set options your generator expects every service watcher config
+      # to supply, providing, for example, default values. This is also a
+      # good place to raise errors in case any options are invalid.
+    end
+  end
+end
+```
+
+### Generator Plugin Inteface
+Synapse deduces both the class path and class name from any additional keys
+passed to the top level configuration, which it assumes are equal to the `NAME`
+of some ConfigGenerator. For example, if `haproxy` is set at the top level we
+try to load the `Haproxy` `ConfigGenerator`.
+
+#### Class Location
+Synapse expects to find your class at `synapse/config_generator/#{name}`. You
+must make your generator available at that path, and Synapse can "just work" and
+find it.
+
+#### Class Name
+These type strings are then transformed into class names via the following
+function:
+
+```
+type_class  = type.split('_').map{|x| x.capitalize}
+```
+
+This has the effect of taking the method, splitting on `_`, capitalizing each
+part and recombining. So `file_output` becomes `FileOutput` and `haproxy`
+becomes `Haproxy`. Make sure your class name is correct.

data/lib/synapse/config_generator/base.rb

@@ -0,0 +1,44 @@
+require 'synapse/log'
+
+class Synapse::ConfigGenerator
+  class BaseGenerator
+    include Synapse::Logging
+
+    NAME = 'base'.freeze
+
+    attr_reader :opts
+
+    def initialize(opts={})
+      @opts = opts
+    end
+
+    # Exposes NAME as 'name' so we can remain consistent with how we refer to
+    # service_watchers' by generator.name access (instead of
+    # generator.class::NAME) even though the names of generators don't change
+    def name
+      self.class::NAME
+    end
+
+    # The synapse main loop will call this any time watchers change, the
+    # config_generator is responsible for diffing the passed watcher state
+    # against the output configuration
+    def update_config(watchers)
+    end
+
+    # The synapse main loop will call this every tick
+    # of the logical clock (~1s). You can use this to intiate reloads
+    # or restarts in a rate limited fashion
+    def tick
+    end
+
+    # Service watchers have a subsection of their ``services`` entry that is
+    # dedicated to the watcher specific configuration for how to configure
+    # the config generator. This method will be called with each of these
+    # watcher hashes, and should normalize them to what the config generator
+    # needs, such as adding defaults. Return the properly populated default hash
+    def normalize_watcher_provided_config(service_watcher_name, service_watcher_config)
+      service_watcher_config.dup
+    end
+
+  end
+end

data/lib/synapse/{file_output.rb → config_generator/file_output.rb}

@@ -1,12 +1,17 @@
+require 'synapse/config_generator/base'
+
 require 'fileutils'
 require 'tempfile'
 
-module Synapse
-  class FileOutput
-    include Logging
-    attr_reader :opts, :name
+class Synapse::ConfigGenerator
+  class FileOutput < BaseGenerator
+    include Synapse::Logging
+
+    NAME = 'file_output'.freeze
 
     def initialize(opts)
+      super(opts)
+
       unless opts.has_key?("output_directory")
         raise ArgumentError, "flat file generation requires an output_directory key"
       end
@@ -16,9 +21,6 @@ module Synapse
       rescue SystemCallError => err
         raise ArgumentError, "provided output directory #{opts['output_directory']} is not present or creatable"
       end
-
-      @opts = opts
-      @name = 'file_output'
     end
 
     def tick(watchers)
@@ -32,7 +34,7 @@ module Synapse
     end
 
     def write_backends_to_file(service_name, new_backends)
-      data_path = File.join(@opts['output_directory'], "#{service_name}.json")
+      data_path = File.join(opts['output_directory'], "#{service_name}.json")
       begin
         old_backends = JSON.load(File.read(data_path))
       rescue Errno::ENOENT
@@ -45,8 +47,8 @@ module Synapse
         # internal state only when the smartstack state has actually changed
         return false
       else
-        # Atomically write new sevice configuration file
-        temp_path = File.join(@opts['output_directory'],
+        # Atomically write new service configuration file
+        temp_path = File.join(opts['output_directory'],
                               ".#{service_name}.json.tmp")
         File.open(temp_path, 'w', 0644) {|f| f.write(new_backends.to_json)}
         FileUtils.mv(temp_path, data_path)
@@ -56,7 +58,7 @@ module Synapse
 
     def clean_old_watchers(current_watchers)
       # Cleanup old services that Synapse no longer manages
-      FileUtils.cd(@opts['output_directory']) do
+      FileUtils.cd(opts['output_directory']) do
         present_files = Dir.glob('*.json')
         managed_files = current_watchers.collect {|watcher| "#{watcher.name}.json"}
         files_to_purge = present_files.select {|svc| not managed_files.include?(svc)}

data/lib/synapse/{haproxy.rb → config_generator/haproxy.rb}

@@ -1,12 +1,15 @@
+require 'synapse/config_generator/base'
+
 require 'fileutils'
 require 'json'
 require 'socket'
 require 'digest/sha1'
 
-module Synapse
-  class Haproxy
-    include Logging
-    attr_reader :opts
+class Synapse::ConfigGenerator
+  class Haproxy < BaseGenerator
+    include Synapse::Logging
+
+    NAME = 'haproxy'.freeze
 
     # these come from the documentation for haproxy (1.5 and 1.6)
     # http://haproxy.1wt.eu/download/1.5/doc/configuration.txt
@@ -790,31 +793,31 @@ module Synapse
 
     DEFAULT_STATE_FILE_TTL = (60 * 60 * 24).freeze # 24 hours
     STATE_FILE_UPDATE_INTERVAL = 60.freeze # iterations; not a unit of time
+    DEFAULT_BIND_ADDRESS = 'localhost'
 
     def initialize(opts)
-      super()
+      super(opts)
 
-      %w{global defaults reload_command}.each do |req|
+      %w{global defaults}.each do |req|
         raise ArgumentError, "haproxy requires a #{req} section" if !opts.has_key?(req)
       end
 
+      @opts['do_writes'] = true unless @opts.key?('do_writes')
+      @opts['do_socket'] = true unless @opts.key?('do_socket')
+      @opts['do_reloads'] = true unless @opts.key?('do_reloads')
+
       req_pairs = {
         'do_writes' => 'config_file_path',
         'do_socket' => 'socket_file_path',
-        'do_reloads' => 'reload_command'}
+        'do_reloads' => 'reload_command'
+      }
 
       req_pairs.each do |cond, req|
-        if opts[cond]
-          raise ArgumentError, "the `#{req}` option is required when `#{cond}` is true" unless opts[req]
+        if @opts[cond]
+          raise ArgumentError, "the `#{req}` option is required when `#{cond}` is true" unless @opts[req]
         end
       end
 
-      @opts = opts
-
-      @opts['do_writes'] = true unless @opts.key?('do_writes')
-      @opts['do_socket'] = true unless @opts.key?('do_socket')
-      @opts['do_reloads'] = true unless @opts.key?('do_reloads')
-
       # socket_file_path can be a string or a list
       # lets make a new option which is always a list (plural)
       @opts['socket_file_paths'] = [@opts['socket_file_path']].flatten
@@ -835,8 +838,19 @@ module Synapse
       @state_file_ttl = @opts.fetch('state_file_ttl', DEFAULT_STATE_FILE_TTL).to_i
     end
 
-    def name
-      'haproxy'
+    def normalize_watcher_provided_config(service_watcher_name, service_watcher_config)
+      service_watcher_config = super(service_watcher_name, service_watcher_config)
+      defaults = {
+        'server_options' => "",
+        'server_port_override' => nil,
+        'backend' => [],
+        'frontend' => [],
+        'listen' => [],
+      }
+      unless service_watcher_config.include?('port')
+        log.warn "synapse: service #{service_watcher_name}: haproxy config does not include a port; only backend sections for the service will be created; you must move traffic there manually using configuration in `extra_sections`"
+      end
+      defaults.merge(service_watcher_config)
     end
 
     def tick(watchers)
@@ -848,13 +862,13 @@ module Synapse
 
       # We potentially have to restart if the restart was rate limited
       # in the original call to update_config
-      restart if @opts['do_reloads'] && @restart_required
+      restart if opts['do_reloads'] && @restart_required
     end
 
     def update_config(watchers)
       # if we support updating backends, try that whenever possible
-      if @opts['do_socket']
-        @opts['socket_file_paths'].each do |socket_path|
+      if opts['do_socket']
+        opts['socket_file_paths'].each do |socket_path|
           update_backends_at(socket_path, watchers)
         end
       else
@@ -865,9 +879,9 @@ module Synapse
       new_config = generate_config(watchers)
 
       # if we write config files, lets do that and then possibly restart
-      if @opts['do_writes']
+      if opts['do_writes']
         write_config(new_config)
-        restart if @opts['do_reloads'] && @restart_required
+        restart if opts['do_reloads'] && @restart_required
       end
     end
 
@@ -877,14 +891,19 @@ module Synapse
       shared_frontend_lines = generate_shared_frontend
 
       watchers.each do |watcher|
+        watcher_config = watcher.config_for_generator[name]
         @watcher_configs[watcher.name] ||= parse_watcher_config(watcher)
+        next if watcher_config['disabled']
         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
+        if watcher_config.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}")
+            tabbed_shared_frontend = watcher_config['shared_frontend'].map{|l| "\t#{l}"}
+            shared_frontend_lines << validate_haproxy_stanza(
+              tabbed_shared_frontend, "frontend", "shared frontend section for #{watcher.name}"
+            )
           end
         end
       end
@@ -896,10 +915,10 @@ module Synapse
 
     # pull out the shared frontend section if any
     def generate_shared_frontend
-      return nil unless @opts.include?('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")
+      shared_frontend_lines << validate_haproxy_stanza(opts['shared_frontend'].map{|l| "\t#{l}"}, "frontend", "shared frontend")
       return shared_frontend_lines
     end
 
@@ -909,13 +928,13 @@ module Synapse
 
       %w{global defaults}.each do |section|
         base_config << "#{section}"
-        @opts[section].each do |option|
+        opts[section].each do |option|
           base_config << "\t#{option}"
         end
       end
 
-      if @opts['extra_sections']
-        @opts['extra_sections'].each do |title, section|
+      if opts['extra_sections']
+        opts['extra_sections'].each do |title, section|
           base_config << "\n#{title}"
           section.each do |option|
             base_config << "\t#{option}"
@@ -930,12 +949,13 @@ module Synapse
     # frontend and backend sections
     def parse_watcher_config(watcher)
       config = {}
+      watcher_config = watcher.config_for_generator[name]
       %w{frontend backend}.each do |section|
-        config[section] = watcher.haproxy[section] || []
+        config[section] = watcher_config[section] || []
 
         # copy over the settings from the 'listen' section that pertain to section
         config[section].concat(
-          watcher.haproxy['listen'].select {|setting|
+          watcher_config['listen'].select {|setting|
             parsed_setting = setting.strip.gsub(/\s+/, ' ').downcase
             SECTION_FIELDS[section].any? {|field| parsed_setting.start_with?(field)}
           })
@@ -961,16 +981,33 @@ module Synapse
 
     # generates an individual stanza for a particular watcher
     def generate_frontend_stanza(watcher, config)
-      unless watcher.haproxy.has_key?("port")
+      watcher_config = watcher.config_for_generator[name]
+      unless watcher_config.has_key?("port")
         log.debug "synapse: not generating frontend stanza for watcher #{watcher.name} because it has no port defined"
         return []
+      else
+        port = watcher_config['port']
       end
 
+
+      bind_address = (
+        watcher_config['bind_address'] ||
+        opts['bind_address'] ||
+        DEFAULT_BIND_ADDRESS
+      )
+      backend_name = watcher_config.fetch('backend_name', watcher.name)
+
+      bind_line = [
+        "\tbind",
+        "#{bind_address}:#{port}",
+        watcher_config['bind_options']
+      ].compact.join(' ')
+
       stanza = [
         "\nfrontend #{watcher.name}",
         config.map {|c| "\t#{c}"},
-        "\tbind #{ watcher.haproxy['bind_address'] || @opts['bind_address'] || 'localhost'}:#{watcher.haproxy['port']}",
-        "\tdefault_backend #{watcher.haproxy.fetch('backend_name', watcher.name)}"
+        bind_line,
+        "\tdefault_backend #{backend_name}"
       ]
     end
 
@@ -1004,7 +1041,8 @@ module Synapse
         log.debug "synapse: no backends found for watcher #{watcher.name}"
       end
 
-      keys = case watcher.haproxy['backend_order']
+      watcher_config = watcher.config_for_generator[name]
+      keys = case watcher_config['backend_order']
       when 'asc'
         backends.keys.sort
       when 'desc'
@@ -1016,20 +1054,20 @@ module Synapse
       end
 
       stanza = [
-        "\nbackend #{watcher.haproxy.fetch('backend_name', watcher.name)}",
+        "\nbackend #{watcher_config.fetch('backend_name', watcher.name)}",
         config.map {|c| "\t#{c}"},
         keys.map {|backend_name|
           backend = backends[backend_name]
           b = "\tserver #{backend_name} #{backend['host']}:#{backend['port']}"
           unless config.include?('mode tcp')
-            b = case watcher.haproxy['cookie_value_method']
+            b = case watcher_config['cookie_value_method']
             when 'hash'
               b = "#{b} cookie #{Digest::SHA1.hexdigest(backend_name)}"
             else
               b = "#{b} cookie #{backend_name}"
             end
           end
-          b = "#{b} #{watcher.haproxy['server_options']}" if watcher.haproxy['server_options']
+          b = "#{b} #{watcher_config['server_options']}" if watcher_config['server_options']
           b = "#{b} #{backend['haproxy_server_options']}" if backend['haproxy_server_options']
           b = "#{b} disabled" unless backend['enabled']
           b }
@@ -1075,6 +1113,7 @@ module Synapse
       watchers.each do |watcher|
         enabled_backends[watcher.name] = []
         next if watcher.backends.empty?
+        next if watcher.config_for_generator[name]['disabled']
 
         unless cur_backends.include? watcher.name
           log.info "synapse: restart required because we added new section #{watcher.name}"
@@ -1125,16 +1164,16 @@ module Synapse
     # writes the config
     def write_config(new_config)
       begin
-        old_config = File.read(@opts['config_file_path'])
+        old_config = File.read(opts['config_file_path'])
       rescue Errno::ENOENT => e
-        log.info "synapse: could not open haproxy config file at #{@opts['config_file_path']}"
+        log.info "synapse: could not open haproxy config file at #{opts['config_file_path']}"
         old_config = ""
       end
 
       if old_config == new_config
         return false
       else
-        File.open(@opts['config_file_path'],'w') {|f| f.write(new_config)}
+        File.open(opts['config_file_path'],'w') {|f| f.write(new_config)}
         return true
       end
     end