first commit

Author: schleyfox

README.md

@@ -0,0 +1,30 @@
+# Example nginx, haproxy, pool-hall, node application
+
+## Running
+
+This is designed to work on linux systems where you have node, npm, haproxy,
+and nginx installed, ideally from your distro's package manager of choice.
+
+Make sure you have ports 9000-9005 open
+
+### nginx
+
+```
+nginx -c nginx.conf -p ./
+```
+
+### haproxy
+
+```
+haproxy -f haproxy_example.cfg
+```
+
+### node example_app
+
+```
+npm install
+npm start
+```
+
+With this you should be able to make requests on http://localhost:9000/health
+and see 'OK'

haproxy_example.cfg

@@ -0,0 +1,64 @@
+# Sample haproxy config for the example app running 4 workers (on 9002 - 9005)
+# Run with haproxy -f haproxy_example.cfg
+global
+  maxconn 2000
+  nbproc 1
+  cpu-map 1 0
+  log 127.0.0.1 local0
+  # by default huge buffers are allocated per backend for storing health check
+  # results. Reduce to save memory, especially when not doing string matching
+  tune.chksize 128
+
+defaults
+  log global
+  option dontlognull
+  option log-separate-errors
+  maxconn 2000
+  # connect timeout on localhost doesn't matter
+  timeout connect 5s
+
+  # adjust this based on how long you can tolerate a request queueing.  Kept
+  # high for the example to demonstrate the impact of queue.
+  timeout queue 5s
+
+  timeout check 5s
+
+  # client and server timeouts should be kept high as haproxy will decrement
+  # the sessions for a backend when the timeout expires.  The backend will
+  # probably still be processing the request at the timeout, so sending a new
+  # request its way would be bad.  This should possibly be infinite, but 60s
+  # should be safe enough with timeouts on the client, especially when
+  # stronger process supervision is added.
+  timeout       client  60s
+  timeout       server  60s
+
+  # enables trying new backends on connection failure
+  option        redispatch
+  retries       3
+
+  balance       static-rr
+  option        http-keep-alive
+
+listen stats_nbproc1 :8999
+  mode http
+  stats enable
+  stats uri /
+  bind-process 1
+
+# example app backends
+frontend example
+  mode http
+  option httplog
+  bind :9001
+  default_backend example
+
+backend example
+  mode http
+  option httplog
+  option tcplog
+
+  # run 4 workers
+  server worker1 127.0.0.1:9002 maxconn 1
+  server worker2 127.0.0.1:9003 maxconn 1
+  server worker3 127.0.0.1:9004 maxconn 1
+  server worker4 127.0.0.1:9005 maxconn 1

index.js

@@ -0,0 +1,96 @@
+const express = require('express');
+const process = require('process');
+const { poolHall, startPoolHall } = require('pool-hall');
+
+const app = express();
+
+function timeToMs(tuple) {
+  return (tuple[0] * 1000) + (tuple[1] / 1000000);
+}
+
+function spinWait(ms) {
+  const start = process.hrtime();
+
+  while(timeToMs(process.hrtime(start)) < ms) {
+  }
+}
+
+startPoolHall(
+  {
+    workerCount: 4,
+    // never go unhealthy because of dead processes
+    minWorkerCount: 0,
+    workerEnv: id => ({ PORT: 9001 + (+id) })
+  },
+  // supervisor
+  () => {
+    process.title = 'node example_app supervisor';
+
+    process.on('SIGTERM', () => {
+      console.log('Got SIGTERM. Going down.');
+      poolHall.stop().then(() => process.exit(0), () => process.exit(1));
+    });
+
+    process.on('SIGINT', () => {
+      console.log('Got SIGINT. Going down.');
+      poolHall.stop().then(() => process.exit(0), () => process.exit(1));
+    });
+
+    poolHall.on('workerUp', (id) => {
+      console.log(`Worker ${id} is up`);
+    });
+
+    poolHall.on('workerDown', (id, info) => {
+      console.log(`Worker ${id} is down with code ${info.signalCode || info.exitCode}`);
+    });
+  },
+  // worker
+  (ready) => {
+    const workerId = poolHall.worker.id;
+
+    process.title = `node example_app worker[${workerId}]`;
+
+    const app = express();
+
+    let healthy = false;
+    let booted = false;
+
+    poolHall.worker.on('healthy', () => {
+      if (!healthy) {
+        console.log(`Worker ${workerId} is healthy`);
+      }
+      healthy = true;
+      booted = true;
+    });
+
+    poolHall.worker.on('unhealthy', () => {
+      if (healthy && booted) {
+        console.log(`Worker ${workerId} is unhealthy`);
+      }
+      healthy = false;
+    });
+
+    app.get('/health', (req, res) => {
+      if (healthy) {
+        res.type('text').send('OK\n');
+      } else {
+        res.status(503).send('NOPE\n');
+      }
+    });
+
+    app.get("/infinite", (req, res) => {
+      while(true) {
+      }
+      res.type('text').send('This is awkward\n');
+    });
+
+    app.get('/render', (req, res) => {
+      spinWait(200);
+      res.type('text').send('DONE\n');
+    });
+
+    const server = app.listen(process.env.PORT, "localhost", ready);
+
+    poolHall.worker.onShutdown = () => server.close(() => process.exit(0));
+  }
+);

logs/.gitignore

@@ -0,0 +1,102 @@
+# Sample nginx config to run a server on localhost:9000 that proxies to an
+# haproxy on localhost:9001.  This is a heavily simplified version of what we
+# run.
+#
+# Run with nginx -c nginx.conf -p ./
+
+# Run a single worker process as that is sufficent to saturate our backend
+worker_processes 1;
+
+worker_rlimit_nofile 1048576;
+
+pid logs/nginx.pid;
+
+events {
+  worker_connections 768;
+}
+
+# settings necessary to run unprivileged in foreground
+daemon off;
+error_log logs/error.log;
+
+http {
+  client_max_body_size 5M;
+
+  # settings necessary to run unprivileged in foreground
+  proxy_temp_path tmp/proxy;
+  client_body_temp_path tmp/body;
+  fastcgi_temp_path tmp/fastcgi;
+  uwsgi_temp_path tmp/uwsgi;
+  scgi_temp_path tmp/scgi;
+  access_log logs/access.log;
+  error_log logs/error.log;
+
+  proxy_read_timeout 600s;
+
+  sendfile on;
+  tcp_nopush on;
+  tcp_nodelay on;
+  keepalive_timeout 65;
+  server_tokens off;
+
+  include /etc/nginx/mime.types;
+  default_type application/octet-stream;
+
+  gzip on;
+  gzip_disable "msie6";
+
+  # relevant part of config
+
+  upstream example_app {
+    # our app listens on port 9001
+    server 127.0.0.1:9001 fail_timeout=0;
+  }
+
+  server {
+    # nginx listens on 9000
+    listen 9000 default_server;
+
+    # size of buffer for request body before spilling to disk.
+    # We've set this high as our renderer process large requests.
+    client_body_buffer_size 1m;
+
+    # absolute limit for client body size, analogous to body-parser's limit
+    client_max_body_size 5m;
+
+    # Response headers buffer size
+    proxy_buffer_size 8k;
+    # Response body buffers (1m)
+    proxy_buffers 8 128k;
+
+    # default route
+    location / {
+      proxy_http_version 1.1;
+      proxy_set_header Connection "";
+      proxy_set_header Host $http_host;
+      proxy_set_header X-Forwarded-Proto $scheme;
+      proxy_redirect off;
+      proxy_pass http://example_app;
+    }
+
+    # special case for /health that proxies request with smaller buffers
+    location = /health {
+      proxy_http_version 1.1;
+      proxy_set_header Connection "";
+      proxy_set_header Host $http_host;
+      proxy_set_header X-Forwarded-Proto $scheme;
+
+      # set smaller buffers for /health
+      client_body_buffer_size 8k;
+      proxy_buffers 8 8k;
+      proxy_redirect off;
+      proxy_pass http://example_app;
+    }
+
+    # offload /ping connectivity check so that it never hits the node app
+    location = /ping {
+      return 200 'PONG
+';
+    }
+  }
+}
+

nginx.conf

@@ -0,0 +1,13 @@
+{
+  "name": "example-node-ops",
+  "version": "0.0.1",
+  "description": "example of a node server with nginx, haproxy, pool-hall",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "express": "^4.16.3",
+    "pool-hall": "^0.0.2"
+  }
+}