We Shall See

# some task that creates kafka topics
when: inventory_hostname == groups["{{some_var}}-kafka"][0]

// do some logic to make sure we are who we say we are.
// then just set the auth session to some non-null object.

request.auth.session.set({must: 'be any old non-null object'});

request.auth.session.clear();

var hapi = require('hapi');
var cookie = require('hapi-auth-cookie');
var server = new hapi.Server();

// register the cookie scheme.
server.register(cookie, function(err) {

  // give our auth strategy a name 'any_name_will_do'
  // hapi-auth-cookie's scheme is named 'cookie', so that needs to be
  // the second param.
  server.auth.strategy('any_name_will_do', 'cookie', {
    password: 'G00b#rBuTz',
    cookie: 'yo-cookie',
    isSecure: false
  });
});

// create a route that uses our auth strategy, and you won't 
// be able to get to that route unless you are authenticated.
server.route({
  method: 'GET',
  path: '/private/{foo*}',
  config: {
    auth: 'any_name_will_do',
    handler: {
      directory: {
        path: 'web/private'
      }
    }
  }
});

server.ext('onPostAuth', function(request, reply) {
  console.log('request.auth.credentials', request.path, request.auth.credentials);
  reply.continue();
});

request.auth.credentials /favicon.ico null
request.auth.credentials /private/ {must: 'be any old non-null object'}

// This should be compatible with https://github.com/senchalabs/connect
// Allows you to stick a stack of middleware in to process the request
// and response in a pipeline fashion.
var url = require('url');

var handlers = [];
var errHandlers = [];

// Not sure if this is exactly the same workflow that connect uses but . . .
//
// Loop over all the handlers in order. Each one will process the
// request and/or reponse in some way (or not). As long as the handler
// calls next() we keep going. If one of the handlers doesn't call next()
// we are done (we assume at that point the handler called res.end() or
// something similar).
//
// If one of the handlers calls next(err) we are done with
// handlers and we start looping over the errHandlers. As long as the
// errHandlers call next we keep going. If one of the errHandlers doesn't
// call next we are done.
function handleRequest(req, res) {
  var hI = 0;
  var eI = 0;
  var pf;
  var next = function next(err) {
    if (err) {
      pf = errHandlers[eI++];
    } else {
      pf = handlers[hI++];
    }
    if (!pf) {
      return res.end('not found', 404);
    }
    if (!pf.path || url.parse(req.url).pathname.indexOf(pf.path) === 0) {
      if (pf.fn.length > 3) {
        pf.fn(req, res, err, next);
      } else {
        pf.fn(req, res, next);
      }
    } else {
      next(err);
    }
  };
  next();
}

handleRequest.use = function use(path, fn) {
  if ((typeof path) !== 'string') {
    fn = path;
    path = null;
  }
  if (fn.length > 3) {
    errHandlers.push({
      path: path,
      fn: fn
    });
  } else {
    handlers.push({
      path: path,
      fn: fn
    });
  }
};

module.exports = handleRequest;

var http = require('http');
var serveStatic = require('serve-static');
var send = require('send');
var session = require('cookie-session');
var middleman = require('./app/middleman');
var api = require('./app/api');

middleman.use(session({
  keys: ['#KDIEkd@%vv11', 'xidk4%d']
}));

middleman.use(serveStatic('web'));

api(middleman);

middleman.use(function(req, res, next) {
  send(req, 'web/index.html').pipe(res);
});

var server = http.createServer(middleman);

server.listen(9494);
server.timeout = 2000;

console.log('listening on 9494');

INSERT INTO products (
    upc, 
    title, 
    description, 
    link) 
VALUES (
    123456789, 
    ‘Figment #1 of 5’, 
    ‘THE NEXT DISNEY ADVENTURE IS HERE - STARRING ONE OF DISNEY'S MOST POPULAR CHARACTERS! ’, 
    ‘http://www.amazon.com/dp/B00KGJVRNE?tag=mypred-20’
    )
ON CONFLICT DO UPDATE SET description=excluded.description;

events {
    worker_connections  1024;
}
include servers/*;

127.0.0.1 note

http {
    # So my goal here is to have all static stuff handled by nginx
    # and everything else handled by node app.
    server {
        root /Users/jstein/github/take-note;
        server_name note;
        location / {
            proxy_pass http://localhost:6543;
        }
        # So this allows nginx to serve index.html from
        # /Users/jstein/github/take-note/html if the path matches /
        # exactly. You can have parameters like /?foo=bar&zoo=man#whatever
        location = / {
            root html;
            index  index.html;
        }
        # This location is needed as well to serve index.html as /
        location = /index.html {
            # root /html; # 404 not found
            # root html; # gives me /usr/local/var/www/index.html !?!
            # don't know why i have to put full path in here.
            root /Users/jstein/github/take-note/html;
        }
        # All the rest of our static assets besides index.html should
        # be under specific folders. This is faster than regex and
        # better organization.
        location ^~ /img/ {
            # let the poor users browser our img folder if they want,
            # but then will need to specify the trailing slash.
            autoindex on;
        }
        location ^~ /js/ {
            autoindex on;
        }
        location ^~ /css/ {
            autoindex on;
        }
    }
}

Docroot is: /usr/local/var/www

The default port has been set in /usr/local/etc/nginx/nginx.conf to 8080 so that
nginx can run without sudo.

nginx will load all files in /usr/local/etc/nginx/servers/.

To have launchd start nginx at login:
    ln -sfv /usr/local/opt/nginx/*.plist ~/Library/LaunchAgents
Then to load nginx now:
    launchctl load ~/Library/LaunchAgents/homebrew.mxcl.nginx.plist
Or, if you don't want/need launchctl, you can just run:
    nginx
==> Summary
?  /usr/local/Cellar/nginx/1.8.0: 7 files, 964K

CMD="curl -s http://google.com"
echo "$CMD"
RESULT=$(eval $CMD)
echo "$RESULT"