synapse-aurora 0.11.2

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+.vagrant
+.*sw?
+vendor/
+
+synapse.jar

data/.mailmap

@@ -0,0 +1,3 @@
+<igor.serebryany@airbedandbreakfast.com> <igor47@moomers.org>
+<martin.rhoads@airbnb.com> <ermal14@gmail.com>
+Pierre Carrier <pierre@gcarrier.fr>

data/.nix/Gemfile.nix

@@ -0,0 +1,141 @@
+# WARNING: automatically generated file
+# Generated by 'gem nix' command that comes from 'nix' gem
+g: # Get dependencies from patched gems
+{
+  aliases = {
+    archive_tar_minitar = g.archive_tar_minitar_0_5_2;
+    docker_api = g.docker_api_1_7_6;
+    excon = g.excon_0_42_1;
+    json = g.json_1_8_1;
+    little_plugger = g.little_plugger_1_1_3;
+    logging = g.logging_1_8_2;
+    multi_json = g.multi_json_1_10_1;
+    synapse = g.synapse_0_11_1;
+    zk = g.zk_1_9_4;
+    zookeeper = g.zookeeper_1_4_9;
+  };
+  gem_nix_args = [ ''synapse'' ];
+  gems = {
+    archive_tar_minitar_0_5_2 = {
+      basename = ''archive_tar_minitar'';
+      meta = {
+        description = ''Provides POSIX tarchive management from Ruby programs.'';
+        homepage = ''http://rubyforge.org/projects/ruwiki/'';
+        longDescription = ''Archive::Tar::Minitar is a pure-Ruby library and command-line utility that provides the ability to deal with POSIX tar(1) archive files. The implementation is based heavily on Mauricio Ferna'ndez's implementation in rpa-base, but has been reorganised to promote reuse in other projects.'';
+      };
+      name = ''archive-tar-minitar-0.5.2'';
+      requiredGems = [  ];
+      sha256 = ''1j666713r3cc3wb0042x0wcmq2v11vwwy5pcaayy5f0lnd26iqig'';
+    };
+    docker_api_1_7_6 = {
+      basename = ''docker_api'';
+      meta = {
+        description = ''A simple REST client for the Docker Remote API'';
+        homepage = ''https://github.com/swipely/docker-api'';
+        longDescription = ''A simple REST client for the Docker Remote API'';
+      };
+      name = ''docker-api-1.7.6'';
+      requiredGems = [ g.excon_0_42_1 g.json_1_8_1 g.archive_tar_minitar_0_5_2 ];
+      sha256 = ''1ari4f2rk9w5j5mci7wlqiabqispd2pr9m6qwbqq1ryrlqvksr28'';
+    };
+    excon_0_42_1 = {
+      basename = ''excon'';
+      meta = {
+        description = ''speed, persistence, http(s)'';
+        homepage = ''https://github.com/excon/excon'';
+        longDescription = ''EXtended http(s) CONnections'';
+      };
+      name = ''excon-0.42.1'';
+      requiredGems = [  ];
+      sha256 = ''1za1jmp83149qmykih2bfgxlwyyz3hrpaq4kxww7467fvgwh58xj'';
+    };
+    json_1_8_1 = {
+      basename = ''json'';
+      meta = {
+        description = ''JSON Implementation for Ruby'';
+        homepage = ''http://flori.github.com/json'';
+        longDescription = ''This is a JSON implementation as a Ruby extension in C.'';
+      };
+      name = ''json-1.8.1'';
+      requiredGems = [  ];
+      sha256 = ''0002bsycvizvkmk1jyv8px1hskk6wrjfk4f7x5byi8gxm6zzn6wn'';
+    };
+    little_plugger_1_1_3 = {
+      basename = ''little_plugger'';
+      meta = {
+        description = ''LittlePlugger is a module that provides Gem based plugin management.'';
+        homepage = ''http://gemcutter.org/gems/little-plugger'';
+        longDescription = ''LittlePlugger is a module that provides Gem based plugin management.
+By extending your own class or module with LittlePlugger you can easily
+manage the loading and initializing of plugins provided by other gems.'';
+      };
+      name = ''little-plugger-1.1.3'';
+      requiredGems = [  ];
+      sha256 = ''0crxv0yl5iwmqzj2y7hh9s7qbwr7s7305vgdbsanbzq059ca98yp'';
+    };
+    logging_1_8_2 = {
+      basename = ''logging'';
+      meta = {
+        description = ''A flexible and extendable logging library for Ruby'';
+        homepage = ''http://rubygems.org/gems/logging'';
+        longDescription = ''Logging is a flexible logging library for use in Ruby programs based on the
+design of Java's log4j library. It features a hierarchical logging system,
+custom level names, multiple output destinations per log event, custom
+formatting, and more.'';
+      };
+      name = ''logging-1.8.2'';
+      requiredGems = [ g.little_plugger_1_1_3 g.multi_json_1_10_1 ];
+      sha256 = ''0vcckpk3sffhz9phpzkbbqzzcffsg2n292rmq5b4gx6dp9g4n86p'';
+    };
+    multi_json_1_10_1 = {
+      basename = ''multi_json'';
+      meta = {
+        description = ''A common interface to multiple JSON libraries.'';
+        homepage = ''http://github.com/intridea/multi_json'';
+        longDescription = ''A common interface to multiple JSON libraries, including Oj, Yajl, the JSON gem (with C-extensions), the pure-Ruby JSON gem, NSJSONSerialization, gson.rb, JrJackson, and OkJson.'';
+      };
+      name = ''multi_json-1.10.1'';
+      requiredGems = [  ];
+      sha256 = ''1ll21dz01jjiplr846n1c8yzb45kj5hcixgb72rz0zg8fyc9g61c'';
+    };
+    synapse_0_11_1 = {
+      basename = ''synapse'';
+      meta = {
+        description = '': Write a gem summary'';
+        longDescription = '': Write a gem description'';
+      };
+      name = ''synapse-0.11.1'';
+      requiredGems = [ g.zk_1_9_4 g.docker_api_1_7_6 ];
+      sha256 = ''121ls0ypbz7i24acrldq8dzp8z6a4brl4vxngy51asgjwpalrx52'';
+    };
+    zk_1_9_4 = {
+      basename = ''zk'';
+      meta = {
+        description = ''A high-level wrapper around the zookeeper driver'';
+        homepage = ''https://github.com/slyphon/zk'';
+        longDescription = ''A high-level wrapper around the zookeeper driver
+'';
+      };
+      name = ''zk-1.9.4'';
+      requiredGems = [ g.zookeeper_1_4_9 g.logging_1_8_2 ];
+      sha256 = ''1rgghyhnbqp7lcn0vik3rn93msv51igsh5cwag88rp6hhnvd141j'';
+    };
+    zookeeper_1_4_9 = {
+      basename = ''zookeeper'';
+      meta = {
+        description = ''Apache ZooKeeper driver for Rubies'';
+        homepage = ''https://github.com/slyphon/zookeeper'';
+        longDescription = ''A low-level multi-Ruby wrapper around the ZooKeeper API bindings. For a
+friendlier interface, see http://github.com/slyphon/zk. Currently supported:
+MRI: {1.8.7, 1.9.2, 1.9.3}, JRuby: ~> 1.6.7, Rubinius: 2.0.testing, REE 1.8.7.
+
+This library uses version 3.4.5 of zookeeper bindings.
+
+'';
+      };
+      name = ''zookeeper-1.4.9'';
+      requiredGems = [  ];
+      sha256 = ''1zjb8sri15nqyqv1w9v34dv2d7q1lf3phr126mcfrj8v6vawhzcc'';
+    };
+  };
+}

data/.nix/rubylibs.nix

@@ -0,0 +1,42 @@
+{ stdenv, config, fetchurl, callPackage
+, gemfile ? ./Gemfile.nix
+, patches ? null
+, overrides ? null
+}:
+
+let
+  inherit (stdenv.lib) fold optional;
+  gemsMergeableFun = { generatedFuns ? [], patchFuns ? [], overrideFuns ? [] }:
+  let
+    generatedAttrs = map (f: f customGems) generatedFuns;
+    generatedGems = map (a: a.gems) generatedAttrs;
+    gem = callPackage <nixpkgs/pkgs/development/interpreters/ruby/gem.nix> {
+      patches = map (f: callPackage f { inherit gems; }) patchFuns;
+      overrides = map (f: callPackage f { }) overrideFuns;
+    };
+    customGems = stdenv.lib.mapAttrs gem (fold (x: y: x // y) { } generatedGems);
+    gems = fold (x: y: x // y) customGems (map (a: a.aliases) generatedAttrs);
+  in
+  gems // {
+    merge = { generated ? null, patches ? null, overrides ? null }:
+      gemsMergeableFun {
+        generatedFuns = generatedFuns ++ optional (generated != null) generated;
+        patchFuns = patchFuns ++ optional (patches != null) patches;
+        overrideFuns = overrideFuns ++ optional (overrides != null) overrides;
+      };
+  };
+in
+  ((gemsMergeableFun { }).merge {
+    generated = import gemfile;
+    inherit patches;
+    inherit overrides;
+  }).merge (
+    let
+      getLocalGemFun = name: stdenv.lib.attrByPath [ "gems" name ] null config;
+    in
+    {
+      generated = getLocalGemFun "generated";
+      patches = getLocalGemFun "patches";
+      overrides = getLocalGemFun "overrides";
+    }
+  )

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+cache: bundler
+rvm:
+  - 1.9.3
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in synapse.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Airbnb, Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Makefile

@@ -0,0 +1,6 @@
+build: synapse.jar
+
+synapse.jar:
+	jruby -S warble jar
+
+.PHONY: build push

data/README.md

@@ -0,0 +1,339 @@
+[![Build Status](https://travis-ci.org/airbnb/synapse.png?branch=master)](https://travis-ci.org/airbnb/synapse)
+[![Inline docs](http://inch-ci.org/github/airbnb/synapse.png)](http://inch-ci.org/github/airbnb/synapse)
+
+# Synapse #
+
+Synapse is Airbnb's new system for service discovery.
+Synapse solves the problem of automated fail-over in the cloud, where failover via network re-configuration is impossible.
+The end result is the ability to connect internal services together in a scalable, fault-tolerant way.
+
+## Motivation ##
+
+Synapse emerged from the need to maintain high-availability applications in the cloud.
+Traditional high-availability techniques, which involve using a CRM like [pacemaker](http://linux-ha.org/wiki/Pacemaker), do not work in environments where the end-user has no control over the networking.
+In an environment like Amazon's EC2, all of the available workarounds are suboptimal:
+
+* Round-robin DNS: Slow to converge, and doesn't work when applications cache DNS lookups (which is frequent)
+* Elastic IPs: slow to converge, limited in number, public-facing-only, which makes them less useful for internal services
+* ELB: Again, public-facing only, and only useful for HTTP
+
+One solution to this problem is a discovery service, like [Apache Zookeeper](http://zookeeper.apache.org/).
+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 is subject to failure
+* Requires additional servers/instances
+
+Synapse solves these difficulties in a simple and fault-tolerant way.
+
+## How Synapse Works ##
+
+Synapse runs on your application servers; here at Airbnb, we just run it on every box we deploy.
+The heart of synapse is actually [HAProxy](http://haproxy.1wt.eu/), a stable and proven routing component.
+For every external service that your application talks to, we assign a synapse local port on localhost.
+Synapse creates a proxy from the local port to the service, and you reconfigure your application to talk to the proxy.
+
+Synapse comes with a number of `watchers`, which are responsible for service discovery.
+The synapse watchers take care of re-configuring the proxy so that it always points at available servers.
+We've included a number of default watchers, including ones that query zookeeper and ones using the AWS API.
+It is easy to write your own watchers for your use case, and we encourage submitting them back to the project.
+
+## Example Migration ##
+
+Let's suppose your rails application depends on a Postgres database instance.
+The database.yaml file has the DB host and port hardcoded:
+
+```yaml
+production:
+  database: mydb
+  host: mydb.example.com
+  port: 5432
+```
+
+You would like to be able to fail over to a different database in case the original dies.
+Let's suppose your instance is running in AWS and you're using the tag 'proddb' set to 'true' to indicate the prod DB.
+You set up synapse to proxy the DB connection on `localhost:3219` in the `synapse.conf.yaml` file.
+Add a hash under `services` that looks like this:
+
+```yaml
+---
+ services:
+  proddb:
+   default_servers:
+    -
+     name: "default-db"
+     host: "mydb.example.com"
+     port: 5432
+   discovery:
+    method: "awstag"
+    tag_name: "proddb"
+    tag_value: "true"
+   haproxy:
+    port: 3219
+    server_options: "check inter 2000 rise 3 fall 2"
+    frontend: mode tcp
+    backend: mode tcp
+```
+
+And then change your database.yaml file to look like this:
+
+```yaml
+production:
+  database: mydb
+  host: localhost
+  port: 3219
+```
+
+Start up synapse.
+It will configure HAProxy with a proxy from `localhost:3219` to your DB.
+It will attempt to find the DB using the AWS API; if that does not work, it will default to the DB given in `default_servers`.
+In the worst case, if AWS API is down and you need to change which DB your application talks to, simply edit the `synapse.conf.json` file, update the `default_servers` and restart synapse.
+HAProxy will be transparently reloaded, and your application will keep running without a hiccup.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'synapse'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install synapse
+    
+
+Don't forget to install HAProxy prior to installing Synapse.
+
+## Configuration ##
+
+Synapse depends on a single config file in JSON format; it's usually called `synapse.conf.json`.
+The file has two main sections.
+The first is the `services` section, which lists the services you'd like to connect.
+The second is the `haproxy` section, which specifies how to configure and interact with HAProxy.
+
+### Configuring a Service ###
+
+The services are 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:
+
+* `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`: how will the haproxy section for this service be configured
+
+#### Service Discovery ####
+
+We've included a number of `watchers` which provide service discovery.
+Put these into the `discovery` section of the service hash, with these options:
+
+##### Stub #####
+
+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
+
+##### Zookeeper #####
+
+This watcher retrieves a list of servers from zookeeper.
+It takes the following options:
+
+* `method`: zookeeper
+* `path`: the zookeeper path where ephemeral nodes will be created for each available service server
+* `hosts`: the list of zookeeper servers to query
+
+The watcher assumes that each node under `path` represents a service server.
+Synapse attempts to decode the data in each of these nodes using JSON and also using Thrift under the standard Twitter service encoding.
+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/reference/api/docker_remote_api/).
+It takes the following options:
+
+* `method`: docker
+* `servers`: a list of servers running docker as a daemon. Format is `{"name":"...", "host": "..."[, port: 4243]}`
+* `image_name`: find containers running this image
+* `container_port`: find containers forwarding this port
+* `check_interval`: how often to poll the docker API on each server. Default is 15s.
+
+##### AWS EC2 tags #####
+
+This watcher retrieves a list of Amazon EC2 instances that have a tag
+with particular value using the AWS API.
+It takes the following options:
+
+* `method`: ec2tag
+* `tag_name`: the name of the tag to inspect. As per the AWS docs,
+  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.
+
+The following options are optional, provided the well-known `AWS_`
+environment variables shown are set. If supplied, these options will
+be used in preference to the `AWS_` environment variables.
+
+* `aws_access_key_id`: AWS key or set `AWS_ACCESS_KEY_ID` in the environment.
+* `aws_secret_access_key`: AWS secret key or set `AWS_SECRET_ACCESS_KEY` in the environment.
+* `aws_region`: AWS region (i.e. `us-east-1`) or set `AWS_REGION` in the environment.
+
+#### Listing Default Servers ####
+
+You may list a number of default servers providing a service.
+Each hash in that section has the following options:
+
+* `name`: a human-readable name for the default server; must be unique
+* `host`: the host or IP address of the server
+* `port`: the port where the service runs on the `host`
+
+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.  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 its own hash, which should contain the following keys:
+
+* `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`
+* `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.
+* `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
+* `listen`: these lines will be parsed and placed in the correct `frontend`/`backend` section as applicable; you can put lines which are the same for the frontend and backend here.
+* `shared_frontend`: optional: haproxy configuration directives for a shared http frontend (see below)
+
+### Configuring HAProxy ###
+
+The `haproxy` section of the config file has the following options:
+
+* `reload_command`: the command Synapse will run to reload HAProxy
+* `config_file_path`: where Synapse will write the HAProxy config file
+* `do_writes`: whether or not the config file will be written (default to `true`)
+* `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
+* `extra_sections`: additional, manually-configured `frontend`, `backend`, or `listen` stanzas
+* `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.
+If you configure an `address:port` combination that is already in use on the system, haproxy will fail to start.
+
+### 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
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+### Creating a Service Watcher ###
+
+If you'd like to create a new service watcher:
+
+1. Create a file for your watcher in `service_watcher` dir
+2. Use the following template:
+```ruby
+require 'synapse/service_watcher/base'
+
+module Synapse
+  class NewWatcher < BaseWatcher
+    def start
+      # write code which begins running service discovery
+    end
+
+    private
+    def validate_discovery_opts
+      # here, validate any required options in @discovery
+    end
+  end
+end
+```
+
+3. Implement the `start` and `validate_discovery_opts` methods
+4. Implement whatever additional methods your discovery requires
+
+When your watcher detects a list of new backends, they should be written to `@backends`.
+You should then call `@synapse.configure` to force synapse to update the HAProxy config.