Merged with twitter

.gitignore

@@ -15,3 +15,4 @@ lib_managed/
 .ivyjars
 out/
 sbt-launch.jar
+example/*.class

.travis.yml

@@ -1,25 +1,24 @@
-sudo: true
 language: scala
 
 scala:
   - 2.10.5
   - 2.11.7
 
 jdk:
-  - openjdk7
   - oraclejdk7
   - oraclejdk8
 
 cache:
   directories:
     - $HOME/.ivy2/cache
-    - $HOME/.sbt/boot
+    - $HOME/.sbt/boot/scala-$TRAVIS_SCALA_VERSION
 
-script:
-  - unset SBT_OPTS
-  - ./sbt ++$TRAVIS_SCALA_VERSION clean coverage test coverageReport
+before_script: unset SBT_OPTS
+
+script: sbt clean coverage test coverageReport
+
+after_script:
   - find $HOME/.sbt -name "*.lock" | xargs rm
   - find $HOME/.ivy2 -name "ivydata-*.properties" | xargs rm
 
 after_success: bash <(curl -s https://codecov.io/bash)
-

README.md

@@ -1,5 +1,6 @@
 # Diffy
 
+[![GitHub license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 [![Build status](https://img.shields.io/travis/twitter/diffy/master.svg)](https://travis-ci.org/twitter/diffy)
 [![Coverage status](https://img.shields.io/codecov/c/github/twitter/diffy/master.svg)](https://codecov.io/github/twitter/diffy)
 [![Project status](https://img.shields.io/badge/status-active-brightgreen.svg)](#status)
@@ -19,6 +20,7 @@ the running instances. It then compares the responses, and reports any regressio
 from those comparisons. The premise for Diffy is that if two implementations of the service return
 “similar” responses for a sufficiently large and diverse set of requests, then the two
 implementations can be treated as equivalent and the newer implementation is regression-free.
+For a more detailed analysis of Diffy checkout this [blogpost](https://blog.twitter.com/engineering/en_us/a/2015/diffy-testing-services-without-writing-tests.html).
 
 ## How does Diffy work?
 
@@ -37,28 +39,29 @@ things:
 2. Non-deterministic noise observed between the primary and secondary instances. Since both of these
    instances are running known-good code, you should expect responses to be in agreement. If not,
    your service may have non-deterministic behavior, which is to be expected.
+![Diffy Topology](https://g.twimg.com/blog/blog/image/Diffy_2.png)
 
 Diffy measures how often primary and secondary disagree with each other vs. how often primary and
 candidate disagree with each other. If these measurements are roughly the same, then Diffy
 determines that there is nothing wrong and that the error can be ignored.
 
 ## How to get started?
+# Running the example
+The example.sh script included here builds and launches example servers as well as a diffy instance. Verify 
+that the following ports are available (9000, 9100, 9200, 8880, 8881, & 8888) and run `./example/run.sh start`.
 
-First, you need to build Diffy by invoking `./sbt assembly` from your diffy directory. This will create 
-a diffy jar at `diffy/target/scala-2.11/diffy-server.jar`.
-
-Diffy comes bundled with an example.sh script that you can run to start comparing examples instances 
-we have already deployed online. Once your local Diffy instance is deployed, you send it a few requests 
-via `curl --header "Canonical-Resource: Html" localhost:8880` and `curl --header "Canonical-Resource: Json" localhost:8880/json`. You can then go to your browser at 
+Once your local Diffy instance is deployed, you send it a few requests 
+like `curl --header "Canonical-Resource: Json" localhost:8880/json?Twitter`. You can then go to your browser at 
 [http://localhost:8888](http://localhost:8888) to see what the differences across our example instances look like.
 
+# Digging deeper
 That was cool but now you want to compare old and new versions of your own service. Here’s how you can 
 start using Diffy to compare three instances of your service:
 
 1. Deploy your old code to `localhost:9990`. This is your primary.
 2. Deploy your old code to `localhost:9991`. This is your secondary.
 3. Deploy your new code to `localhost:9992`. This is your candidate.
-4. Download the latest Diffy binary or build your own from the code.
+4. Download the latest Diffy binary from maven central or build your own from the code using `./sbt assembly`.
 5. Run the Diffy jar with following command line arguments:
 
     ```
@@ -68,27 +71,31 @@ start using Diffy to compare three instances of your service:
     -master.secondary=localhost:9991 \
     -service.protocol=http \
     -serviceName=My-Service \
-    -proxy.port=:31900 \
-    -admin.port=:31159 \
-    -http.port=:31149 \
-    -rootUrl='localhost:31149'
+    -proxy.port=:8880 \
+    -admin.port=:8881 \
+    -http.port=:8888 \
+    -rootUrl='localhost:8888'
     ```
 
 6. Send a few test requests to your Diffy instance on its proxy port:
 
     ```
-    curl localhost:31900/your/application/route?with=queryparams
+    curl localhost:8880/your/application/route?with=queryparams
     ```
 
-7. Watch the differences show up in your browser at [http://localhost:31149](http://localhost:31149).
-
-### Running example on docker-compose
+7. Watch the differences show up in your browser at [http://localhost:8888](http://localhost:8888).
 
-Inside the example directory you will find instructions to run a complete example with apis and diffy configured and ready to run using docker-compose.
-
 ## FAQ's
    For safety reasons `POST`, `PUT`, ` DELETE ` are ignored by default . Add ` -allowHttpSideEffects=true ` to your command line arguments to enable these verbs.
 
+## HTTPS
+If you are trying to run Diffy over a HTTPS API, the config required is:
+
+    -service.protocol=https
+
+And in case of the HTTPS port be different than 443:
+
+    -https.port=123
 
 ## License
 

example/ExampleServers.java

@@ -0,0 +1,71 @@
+import java.net.InetSocketAddress;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+
+public class ExampleServers {
+    public static void main(String[] args) throws Exception {
+        int primary = Integer.parseInt(args[0]);
+        int secondary = Integer.parseInt(args[1]);
+        int candidate = Integer.parseInt(args[2]);
+        Thread p = new Thread(() -> bind(primary, x -> x.toLowerCase()));
+        Thread s = new Thread(() -> bind(secondary, x -> x.toLowerCase()));
+        Thread c = new Thread(() -> bind(candidate, x -> x.toUpperCase()));
+        p.start();
+        s.start();
+        c.start();
+        while(true){
+            Thread.sleep(10);
+        }
+    }
+
+    public static void bind(int port, Function<String, String> lambda) {
+        try {
+            HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);
+            server.createContext(
+                    "/json",
+                    new Handler(
+                            "{\"name\":\"%s\", \"timestamp\":\"%s\"}",
+                            "application/json",
+                            lambda));
+            server.createContext(
+                    "/html",
+                    new Handler(
+                            "<body><name>%s</name><timestamp>%s</timestamp></body>",
+                            "text/html",
+                            lambda));
+            server.setExecutor(null);
+            server.start();
+        } catch (Exception exception) {
+            System.err.println("!!!failed to start!!!");
+        }
+    }
+}
+class Handler implements HttpHandler {
+    private String template;
+    private String contentType;
+    private Function<String, String> lambda;
+    public Handler(String template, String contentType, Function<String, String> lambda) {
+        super();
+        this.template = template;
+        this.contentType = contentType;
+        this.lambda = lambda;
+    }
+
+    @Override
+    public void handle(HttpExchange t) throws IOException {
+        String name  = lambda.apply(t.getRequestURI().getQuery());
+        String response = String.format(template, name, System.currentTimeMillis());
+        System.out.println(response);
+        t.getResponseHeaders().add("Content-Type", contentType);
+        t.sendResponseHeaders(200, response.length());
+        OutputStream os = t.getResponseBody();
+        os.write(response.getBytes());
+        os.close();
+    }
+}