cf-registrar 1.0.3

data/README.md

@@ -0,0 +1,34 @@
+# Cf::Registrar
+
+[![Build Status](https://travis-ci.org/cloudfoundry/cf-registrar.png?branch=master)](https://travis-ci.org/cloudfoundry/cf-registrar)
+
+[![Code Climate](https://codeclimate.com/repos/52e301fd6956803ff1003c85/badges/c66e290472608e6af5f9/gpa.png)](https://codeclimate.com/repos/52e301fd6956803ff1003c85/feed)
+
+Helper to register with common components like Varz and CF Router
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cf-registrar', git: 'https://github.com/cloudfoundry/cf-registrar'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cf-registrar
+
+## Usage
+
+    # Modes can be --register-with-router and --register-varz-credentials
+    $ cf-registrar --<mode1> --<mode2> ...
+
+## Contributing
+
+1. Fork it ( http://github.com/cloudfoundry/cf-registrar/fork )
+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

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['--format', 'documentation', '--colour']
+end

data/bin/cf-registrar

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "yaml"
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require "cf/registrar"
+require "steno"
+require "securerandom"
+
+if ARGV.empty?
+  puts "Usage: cf-registrar --<mode1> --<mode2> ...\n\nModes can be --register-with-router and --register-varz-credentials"
+  exit
+end
+
+config_file = ENV["CONFIG_FILE"] || File.expand_path("../config/registrar.example.yml", File.dirname(__FILE__))
+config = YAML.load_file(config_file)
+
+Steno.init(Steno::Config.from_hash(config["logging"]))
+logger = Steno.logger("cf-registrar")
+
+unless config["varz"]["file"].nil?
+  varz_config = YAML.load_file(config["varz"]["file"])
+  unless varz_config.nil?
+    logger.info "Reading varz config from #{config["varz"]["file"]}"
+    config["varz"] = varz_config["varz"]
+  end
+end
+
+logger.debug("Config #{config.inspect}")
+
+EM.run do
+  cf_registrar = Cf::Registrar.new({
+    :message_bus_servers => config["message_bus_servers"],
+    :host => config["host"],
+    :port => config["port"],
+    :uri => config["uri"],
+    :tags => config["tags"],
+    :index => config["index"],
+    :varz => config["varz"],
+    :private_instance_id => SecureRandom.uuid
+  })
+  if ARGV.include?("--register-with-router") || ARGV.include?("--register_with_router")
+    cf_registrar.register_with_router
+  end
+
+  if ARGV.include?("--register-varz-credentials") || ARGV.include?("--register_varz_credentials")
+    cf_registrar.register_varz_credentials
+  end
+
+  %w[TERM INT QUIT].each do |signal|
+    trap signal do
+      logger.info("Shutting down")
+      if ARGV.include? "--register-with-router"
+        cf_registrar.shutdown { exit }
+      else
+        exit
+      end
+    end
+  end
+end

data/cf-registrar.gemspec

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'lib/cf-registrar/version')
+
+Gem::Specification.new do |spec|
+  spec.name         = 'cf-registrar'
+  spec.version      = CfRegistrar::VERSION.dup
+  spec.authors      = ['CloudFoundry Core Team']
+  spec.email        = ['cfpi-dev@googlegroups.com']
+  spec.summary      = %q{Cloud Foundry registrar}
+  spec.description  = %q{Helper for registering a component with things like Varz and the CF Router.}
+  spec.homepage     = ''
+  spec.license      = 'Apache'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'eventmachine', '~> 1.0.0'
+  spec.add_dependency 'steno'
+  spec.add_dependency 'vcap-concurrency'
+  spec.add_dependency 'cf-message-bus', '~> 0.3.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-its'
+end

data/config/config.yml

@@ -0,0 +1,18 @@
+---
+logging:
+  level: all
+message_bus_servers:
+  - nats://localhost:4222
+uri: test.vcap.me
+# Alternatively, multiple urls are support like so
+# uri:
+#   - test.vcap.me
+#   - abc.vcap.me
+host: localhost
+port: 80
+varz:
+  type: new_component
+  username: varz
+  password: varzclientpassword
+# Absolute path to file containing the varz credentials
+#  file: /tmp/uaa.yml

data/lib/cf-registrar.rb

@@ -0,0 +1 @@
+require "cf/registrar"

data/lib/cf-registrar/version.rb

@@ -0,0 +1,3 @@
+module CfRegistrar
+  VERSION = "1.0.3".freeze
+end

data/lib/cf/registrar.rb

@@ -0,0 +1,142 @@
+require "eventmachine"
+require "steno"
+require "securerandom"
+require "cf_message_bus/message_bus"
+
+module Cf
+  class Registrar
+    DISCOVER_TOPIC = "vcap.component.discover"
+    ANNOUNCE_TOPIC = "vcap.component.announce"
+    ROUTER_START_TOPIC = "router.start"
+    ROUTER_GREET_TOPIC = "router.greet"
+    ROUTER_REGISTER_TOPIC = "router.register"
+    ROUTER_UNREGISTER_TOPIC = "router.unregister"
+
+    attr_reader :logger, :message_bus_servers, :type, :host, :port,
+                :username, :password, :uri, :tags, :uuid, :index, :private_instance_id
+
+    def initialize(config)
+      @logger = Steno.logger("cf.registrar")
+
+      config = symbolize_keys(config)
+
+      @message_bus_servers = config[:message_bus_servers]
+      @host = config[:host]
+      @port = config[:port]
+      @uri = config[:uri]
+      @tags = config[:tags]
+      @index = config[:index] || 0
+      @private_instance_id = config[:private_instance_id]
+
+      if config[:varz]
+        @type = config[:varz][:type]
+        @username = config[:varz][:username]
+        @password = config[:varz][:password]
+        @uuid = config[:varz][:uuid] || SecureRandom.uuid
+      end
+    end
+
+    def register_varz_credentials
+      discover_msg = {
+        :type => type,
+        :host => "#{host}:#{port}",
+        :index => index,
+        :uuid => "#{index}-#{uuid}",
+        :credentials => [username, password]
+      }
+
+      if username.nil? || password.nil?
+        logger.error("Could not register nil varz credentials")
+      else
+        logger.info("Connected to NATS - varz registration")
+
+        message_bus.subscribe(DISCOVER_TOPIC) do |_, reply|
+          logger.debug("Received #{DISCOVER_TOPIC} publishing #{reply.inspect} #{discover_msg.inspect}")
+          message_bus.publish(reply, discover_msg)
+        end
+
+        logger.info("Announcing start up #{ANNOUNCE_TOPIC}")
+        message_bus.publish(ANNOUNCE_TOPIC, discover_msg)
+      end
+    end
+
+    def register_with_router
+      logger.info("Connected to NATS - router registration")
+
+      @router_start_sid = message_bus.subscribe(ROUTER_START_TOPIC) do |message|
+        handle_router_greeting(message)
+      end
+
+      message_bus.request(ROUTER_GREET_TOPIC) do |message|
+        handle_router_greeting(message)
+      end
+
+      send_registration_message
+    end
+
+    def shutdown(&block)
+      EM.cancel_timer(@registration_timer) if @registration_timer
+      unsubscribe_from_router_start
+      send_unregistration_message(&block)
+    end
+
+    private
+
+    def handle_router_greeting(message)
+      send_registration_message
+
+      if (interval = message["minimumRegisterIntervalInSeconds"])
+        setup_interval(interval)
+      end
+    end
+
+    def message_bus
+      @message_bus ||= CfMessageBus::MessageBus.new(
+        servers: message_bus_servers,
+        logger: logger)
+    end
+
+    def send_registration_message
+      logger.debug("Sending registration: #{registry_message}")
+      message_bus.publish(ROUTER_REGISTER_TOPIC, registry_message)
+    end
+
+    def send_unregistration_message(&block)
+      logger.info("Sending unregistration: #{registry_message}")
+      message_bus.publish(ROUTER_UNREGISTER_TOPIC, registry_message, &block)
+    end
+
+    def unsubscribe_from_router_start
+      logger.debug('Unsubscribing from router.start')
+      message_bus.unsubscribe(@router_start_sid)
+    end
+
+    def registry_message
+      {
+        :host => host,
+        :port => port,
+        :uris => Array(uri),
+        :tags => tags,
+        :index => index,
+        :private_instance_id => private_instance_id
+      }
+    end
+
+    def setup_interval(interval)
+      EM.cancel_timer(@registration_timer) if @registration_timer
+
+      @registration_timer = EM.add_periodic_timer(interval) do
+        send_registration_message
+      end
+    end
+
+    def symbolize_keys(hash)
+      return hash unless hash.is_a? Hash
+      Hash[
+        hash.each_pair.map do |k, v|
+            [k.to_sym, symbolize_keys(v)]
+        end
+      ]
+    end
+  end
+end

data/spec/registrar_spec.rb

@@ -0,0 +1,182 @@
+require "spec_helper"
+require 'rspec/its'
+require "cf/registrar"
+require "cf_message_bus/mock_message_bus"
+
+module Cf
+  describe Registrar do
+    let(:message_bus) { CfMessageBus::MockMessageBus.new }
+    let(:bus_uri) { "a message bus uri" }
+    let(:logger) { double(:logger, info: nil, error: nil, debug: nil) }
+    let(:config) do
+      { message_bus_servers: [bus_uri],
+        host: "registrar.host",
+        port: 98765,
+        uri: "fancyuri",
+        tags: "taggy goodness",
+        private_instance_id: "monkey-id",
+        index: "indextastic",
+        varz: {}
+      }
+    end
+
+    let(:registry_message) do
+      {
+        host: config[:host],
+        port: config[:port],
+        uris: Array(config[:uri]),
+        tags: config[:tags],
+        index: "indextastic",
+        private_instance_id: "monkey-id"
+      }
+    end
+
+    before do
+      EM.stub(:cancel_timer)
+      CfMessageBus::MessageBus.stub(:new) { message_bus }
+    end
+
+    subject { described_class.new(config) }
+
+    describe ".new" do
+      let(:config) { { message_bus_servers: ["m"], host: "h", port: "p", uri: "u", tags: "t", index: 1, private_instance_id: "monkey" } }
+
+      its(:logger) { should be_a Steno::Logger }
+      its(:message_bus_servers) { should eq(["m"]) }
+      its(:host) { should eq "h" }
+      its(:port) { should eq "p" }
+      its(:uri) { should eq "u" }
+      its(:tags) { should eq "t" }
+      its(:index) { should eq 1 }
+      its(:private_instance_id) { should eq "monkey" }
+
+      context "when the index is not provided" do
+        let(:config) { { message_bus_servers: ["m"], host: "h", port: "p", uri: "u", tags: "t" } }
+
+        its(:index) { should eq 0 }
+      end
+
+      context "when no varz has been provided" do
+        let(:config) { {} }
+
+        its(:username) { should be_nil }
+        its(:password) { should be_nil }
+        its(:type) { should be_nil }
+        its(:uuid) { should be_nil }
+      end
+
+      context "when there is a varz provided" do
+        let(:config) { { varz: { username: "user", password: "pass", type: "foo", uuid: "123" } } }
+
+        its(:username) { should eq "user" }
+        its(:password) { should eq "pass" }
+        its(:type) { should eq "foo" }
+        its(:uuid) { should eq "123" }
+
+        context "and a uuid is not provided" do
+          let(:config) { { varz: { username: "user", password: "pass", type: "foo" } } }
+
+          its(:uuid) { should_not be_nil }
+        end
+      end
+
+      context "when there are values with String keys" do
+        let(:config) { { "host" => "h", :varz => { "username" => "user" } } }
+
+        its(:host) { should eq "h" }
+        its(:username) { should eq "user" }
+      end
+    end
+
+    describe "#register_with_router" do
+      it "creates the message bus correctly with logger" do
+        CfMessageBus::MessageBus.should_receive(:new).with(servers: [bus_uri], logger: subject.logger)
+        subject.register_with_router
+      end
+
+      it "registers routes immediately" do
+        subject.register_with_router
+        expect(message_bus).to have_published_with_message("router.register", registry_message)
+      end
+
+      it "registers upon a router.start message" do
+        EM.should_receive(:add_periodic_timer).with(33)
+
+        subject.register_with_router
+
+        message_bus.clear_published_messages
+
+        message_bus.publish("router.start", minimumRegisterIntervalInSeconds: 33)
+
+        expect(message_bus).to have_published_with_message("router.register", registry_message)
+      end
+
+      it "greets the router" do
+        EM.should_receive(:add_periodic_timer).with(33)
+
+        subject.register_with_router
+
+        message_bus.clear_published_messages
+
+        message_bus.respond_to_request("router.greet", minimumRegisterIntervalInSeconds: 33)
+      end
+
+      it "periodically registers with the router" do
+        EM.should_receive(:add_periodic_timer).with(33).and_return(:periodic_timer)
+        subject.register_with_router
+        message_bus.publish("router.start", minimumRegisterIntervalInSeconds: 33)
+      end
+
+      it "clears an existing timer when registering a new one" do
+        subject.register_with_router
+
+        EM.should_receive(:add_periodic_timer).with(33).and_return(:periodic_timer)
+        message_bus.publish("router.start", minimumRegisterIntervalInSeconds: 33)
+
+        EM.should_receive(:cancel_timer).with(:periodic_timer)
+        EM.should_receive(:add_periodic_timer).with(24)
+        message_bus.publish("router.start", minimumRegisterIntervalInSeconds: 24)
+      end
+
+      context "when there is no timer interval returned" do
+        it "does not set up a timer" do
+          subject.register_with_router
+
+          EM.should_not_receive(:add_periodic_timer)
+          message_bus.publish("router.start", {})
+        end
+      end
+    end
+
+    describe "#shutdown" do
+      before do
+        subject.register_with_router
+        EM.should_receive(:add_periodic_timer).with(33).and_return(:periodic_timer)
+        message_bus.publish("router.start", minimumRegisterIntervalInSeconds: 33)
+      end
+
+      it "publishes router.unregister" do
+        subject.shutdown
+        expect(message_bus).to have_published_with_message("router.unregister", registry_message)
+      end
+
+      it "stops sending registration messages" do
+        EM.should_receive(:cancel_timer).with(:periodic_timer)
+        subject.shutdown
+      end
+
+      it 'unsubscribes from the router start topic' do
+        subject.shutdown
+
+        message_bus.clear_published_messages
+        message_bus.publish('router.start', minimumRegisterIntervalInSeconds: 33)
+
+        expect(message_bus.has_published?('router.register')).to be_falsey
+      end
+
+      it "calls the given block after sending" do
+        expect { |b| subject.shutdown(&b) }.to yield_control
+      end
+    end
+  end
+end