pantry 0.0.0 → 0.1.0

data/lib/pantry/test/support/fake_fs.rb

@@ -0,0 +1,31 @@
+gem 'fakefs'
+require 'fakefs/safe'
+
+# Hook up FakeFS into Minitest
+class MiniTest::Test
+  def self.fake_fs!
+    before do
+      FakeFS.activate!
+    end
+
+    after do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+  end
+end
+
+# Minitest uses Tempfiles for figuring out more complicated diffs
+# This causes FakeFS to explode, so make sure this is run without FakeFS
+# enabled.
+module Minitest
+  module Assertions
+    alias :actual_diff :diff
+
+    def diff exp, act
+      FakeFS.without do
+        actual_diff exp, act
+      end
+    end
+  end
+end

data/lib/pantry/test/support/matchers.rb

@@ -0,0 +1,13 @@
+# Some custom MiniTest matchers used throughout the system
+
+module Minitest::Assertions
+
+  # I don't like the refute_ syntax, sorry =/
+
+  alias assert_not_nil   refute_nil
+  alias assert_not       refute
+  alias assert_false     refute
+  alias assert_not_equal refute_equal
+  alias assert_no_match  refute_match
+
+end

data/lib/pantry/test/support/minitest.rb

@@ -0,0 +1,13 @@
+require 'minitest/autorun'
+
+# Global helpers we're adding to Minitest
+module PantryMinitestHelpers
+  def before_setup
+    Celluloid.init
+    Pantry.reset_config!
+  end
+end
+
+class Minitest::Test
+  include PantryMinitestHelpers
+end

data/lib/pantry/test/support/mock_ui.rb

@@ -0,0 +1,23 @@
+# For actions that print out or use the console via
+# Pantry.ui, these helpers mock out stdout/stderr to make it easy
+# to grab what's printed and to inject keypresses
+class MiniTest::Test
+  def self.mock_ui!
+    before do
+      @mock_stdin = StringIO.new
+      @mock_stdout = StringIO.new
+      Pantry.reset_ui!
+      Pantry.ui(@mock_stdin, @mock_stdout)
+    end
+  end
+
+  # Return the strings added to stdout through the test
+  def stdout
+    @mock_stdout.string
+  end
+
+  # Get access to the mock of STDIN to add values
+  def stdin
+    @mock_stdin
+  end
+end

data/lib/pantry/test/unit.rb

@@ -0,0 +1,13 @@
+#
+# Require this file to grab the Pantry unit test environment.
+# This environment includes setup helpers to ensure Celluloid is running,
+# as well as a few mocks (ui and fakefs) as well as helpers to facilitate
+# testing Pantry plugins.
+#
+
+require 'pantry'
+require 'celluloid/test'
+require 'pantry/test/support/minitest'
+require 'pantry/test/support/matchers'
+require 'pantry/test/support/mock_ui'
+require 'pantry/test/support/fake_fs'

data/lib/pantry/ui.rb

@@ -0,0 +1,68 @@
+module Pantry
+
+  # Global access to Pantry's UI handler. This object offers up
+  # a set of methods used to interact with the User via the CLI.
+  def self.ui(input = $stdin, output = $stdout)
+    @@ui ||= Pantry::UI.new(input, output)
+  end
+
+  def self.reset_ui!
+    @@ui = nil
+  end
+
+  class UI
+
+    def initialize(input = $stdin, output = $stdout)
+      require 'highline'
+      @output = output
+      @input  = input
+      @highline = HighLine.new(input, output)
+    end
+
+    # Send a message to STDOUT
+    def say(message)
+      @highline.say(message)
+    end
+
+    # Print out a list, attempting to make it look somewhat reasonable
+    def list(array)
+      say(array.join("\n") + "\n")
+    end
+
+    def color(string, color)
+      HighLine.color(string, color)
+    end
+
+    # Show the user a message and ask them to continue by hitting Enter,
+    # or they can cancel with "No"
+    def continue?(message)
+      @highline.agree(message) do |q|
+        q.default = "yes"
+      end
+    end
+
+    # Start a new progress meter with the given number of ticks
+    def progress_start(tick_count)
+      require 'ruby-progressbar'
+      @progress = ProgressBar.create(
+        total: tick_count, output: @output,
+        format: "Progress: %P%% |%B| %c/%C %e"
+      )
+    end
+
+    # Increment the running progress meter the given number of ticks
+    def progress_step(tick_count)
+      if @progress.progress + tick_count > @progress.total
+        tick_count = @progress.total - @progress.progress
+      end
+
+      @progress.progress += tick_count
+    end
+
+    # Complete and close down the current progress meter
+    def progress_finish
+      @progress.finish
+    end
+
+  end
+end

data/lib/pantry/version.rb

@@ -0,0 +1,3 @@
+module Pantry
+  VERSION = "0.1.0"
+end

data/pantry.gemspec

@@ -0,0 +1,40 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "pantry/version"
+
+Gem::Specification.new do |s|
+  s.name     = "pantry"
+  s.version  = Pantry::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors  = ["Collective Idea", "Jason Roelofs"]
+  s.email    = ["code@collectiveidea.com", "jasongroelofs@gmail.com"]
+  s.license  = "MIT"
+  s.homepage = "http://pantryops.org"
+
+  s.summary     = "Modern DevOps Automation"
+  s.description = <<-EOS
+    Pantry is a framework that provides answers to common questions encoutered when setting up a DevOps, server configuration, or server provisioning pipeline.
+  EOS
+
+  s.required_ruby_version = ">= 2.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- test/*`.split("\n")
+  s.require_path = "lib"
+  s.bindir       = "bin"
+
+  s.executables  = %w(pantry-client pantry-server pantry)
+
+  s.requirements << "zeromq 3.x or 4.x"
+  s.requirements << "libsodium for Curve security"
+
+  s.add_runtime_dependency "ffi-rzmq",         "~> 2.0",  ">= 2.0.0"
+  s.add_runtime_dependency "celluloid",        "~> 0.15", ">= 0.15.0"
+  s.add_runtime_dependency "celluloid-zmq",    "~> 0.15", ">= 0.15.0"
+  s.add_runtime_dependency "highline",         "~> 1.6",  ">= 1.6.21"
+  s.add_runtime_dependency "json",             "~> 1.8",  ">= 1.8.1"
+  s.add_runtime_dependency "ruby-progressbar", "~> 1.4",  ">= 1.4.2"
+  s.add_runtime_dependency "safe_yaml",        "~> 1.0",  ">= 1.0.1"
+
+  s.add_development_dependency "mocha",  "~> 1.0", ">= 1.0.0"
+  s.add_development_dependency "fakefs", "~> 0.5", ">= 0.5.1"
+end

data/test/acceptance/cli/error_handling_test.rb

@@ -0,0 +1,7 @@
+require 'acceptance/test_helper'
+
+describe "CLI error handling" do
+
+  it "errors when the server is unavailable"
+
+end

data/test/acceptance/cli/execute_command_on_clients_test.rb

@@ -0,0 +1,32 @@
+require 'acceptance/test_helper'
+
+describe "CLI requests information from individual clients" do
+
+  mock_ui!
+
+  it "receives responses from each client asked" do
+    set_up_environment(ports_start_at: 10100)
+
+    Pantry::CLI.new(
+      ["-a", "pantry", "echo", "This is Neat"],
+      identity: "cli1"
+    ).run
+
+    assert_match %r|Expecting response from 2 clients|, stdout
+    assert_match %r|#{@client1.identity} echo's "This is Neat"|, stdout
+    assert_match %r|#{@client2.identity} echo's "This is Neat"|, stdout
+  end
+
+  it "can target specific clients for the commands sent" do
+    set_up_environment(ports_start_at: 10110)
+
+    Pantry::CLI.new(
+      ["-a", "pantry", "-e", "test", "-r", "app1", "echo", "This is Neat"],
+      identity: "cli1"
+    ).run
+
+    assert_match %r|Expecting response from 1 client|, stdout
+    assert_match %r|#{@client1.identity} echo's \"This is Neat\"|, stdout
+  end
+
+end

data/test/acceptance/cli/request_info_from_server_test.rb

@@ -0,0 +1,44 @@
+require 'acceptance/test_helper'
+
+describe "CLI can ask Server for information" do
+
+  mock_ui!
+
+  it "can ask for all known nodes" do
+    set_up_environment(ports_start_at: 10200)
+
+    Pantry::CLI.new(
+      ["status"],
+      identity: "test_client"
+    ).run
+
+    assert_match /#{@client1.identity}/, stdout, "Did not contain line for client1"
+    assert_match /#{@client2.identity}/, stdout, "Did not contain line for client2"
+  end
+
+  it "can limit the query to a subset of clients" do
+    set_up_environment(ports_start_at: 10210)
+
+    cli = Pantry::CLI.new(
+      ["-a", "chatbot", "status"],
+      identity: "test_client"
+    )
+
+    client3 = Pantry::Client.new(application: "chatbot", identity: "client3")
+    client3.run
+
+    client4 = Pantry::Client.new(application: "chatbot", identity: "client4")
+    client4.run
+
+    cli.run
+
+    assert_equal 2, stdout.split("\n").length
+
+    assert_match /client3/, stdout, "Did not contain line for client3"
+    assert_match /client4/, stdout, "Did not contain line for client4"
+
+    client3.shutdown
+    client4.shutdown
+  end
+
+end

data/test/acceptance/communication/client_requests_info_from_server_test.rb

@@ -0,0 +1,28 @@
+require 'acceptance/test_helper'
+
+describe "Client requests information from the Server" do
+
+  it "asks the server for information and waits for a response" do
+    set_up_environment(ports_start_at: 10300)
+
+    message = ServerEchoCommand.new("Hello Server").to_message
+    response_future = @client1.send_request(message)
+
+    assert_equal ["Hello Server"], response_future.value(2).body
+  end
+
+  it "handles multiple requests in the proper order" do
+    set_up_environment(ports_start_at: 10310)
+
+    futures = []
+    10.times do |i|
+      message = ServerEchoCommand.new("Hello Server #{i}").to_message
+      futures << @client1.send_request(message)
+    end
+
+    futures.each_with_index do |future, idx|
+      assert_equal ["Hello Server #{idx}"], future.value(1).body
+    end
+  end
+
+end

data/test/acceptance/communication/heartbeat_test.rb

@@ -0,0 +1,19 @@
+require 'acceptance/test_helper'
+
+describe "Client / Server heartbeats" do
+
+  describe "Client" do
+    it "re-registers with the server every interval seconds" do
+      set_up_environment(ports_start_at: 10500, heartbeat: 1)
+
+      # Clean out the server registry then wait for clients to re-register themselves
+      @server.client_registry.clear!
+
+      sleep 2
+
+      assert @server.client_registry.include?(@client1), "Client1 did not check in again"
+      assert @server.client_registry.include?(@client2), "Client2 did not check in again"
+    end
+  end
+
+end

data/test/acceptance/communication/pub_sub_communication_test.rb

@@ -0,0 +1,53 @@
+require 'acceptance/test_helper'
+
+describe "Pub/Sub Communication" do
+
+  describe "Server" do
+    it "can publish a message to all connected clients" do
+      set_up_environment(ports_start_at: 10400)
+
+      @server.publish_message(
+        Pantry::Message.new("test_message"),
+        Pantry::Communication::ClientFilter.new(application: "pantry")
+      )
+
+      # Give communication time to happen
+      sleep 1
+
+      assert_equal "test_message", @client1.last_received_message.type
+      assert_equal "test_message", @client2.last_received_message.type
+    end
+
+    it "can publish a message to a subset of all connected clients" do
+      set_up_environment(ports_start_at: 10410)
+
+      client3 = Pantry::Client.new(roles: %w(database), identity: "client3")
+      client3.run
+
+      client4 = Pantry::Client.new(roles: %w(database task), identity: "client4")
+      client4.run
+
+      sleep 1
+
+      @server.publish_message(Pantry::Message.new("to_databases"),
+                              Pantry::Communication::ClientFilter.new(roles: %w(database)))
+
+      # Give communication time to happen
+      sleep 1
+
+      assert_equal "to_databases", client3.last_received_message.type
+      assert_equal "to_databases", client4.last_received_message.type
+
+      @server.publish_message(Pantry::Message.new("to_tasks"),
+                              Pantry::Communication::ClientFilter.new(roles: %w(task)))
+
+      # Give communication time to happen
+      sleep 1
+
+      assert_equal "to_tasks", client4.last_received_message.type
+
+      client3.shutdown
+      client4.shutdown
+    end
+  end
+end

data/test/acceptance/communication/security_test.rb

@@ -0,0 +1,117 @@
+require 'acceptance/test_helper'
+
+describe "ZMQ4 CURVE security" do
+
+  break unless Pantry::Communication::Security.curve_supported?
+
+  def set_up_encrypted(ports_start_at, options = {})
+    Celluloid.boot
+    configure_pantry(ports_start_at: ports_start_at, security: "curve")
+
+    server_public, server_private = ZMQ::Util.curve_keypair
+    client_public, client_private = ZMQ::Util.curve_keypair
+
+    known_clients = options[:known_clients] || [client_public]
+
+    key_dir = Pantry.root.join("security", "curve")
+    FileUtils.mkdir_p(key_dir)
+
+    File.open(key_dir.join("server_keys.yml"), "w+") do |f|
+      f.write(YAML.dump({
+        "private_key" => server_private,
+        "public_key" => options[:server_public_key] || server_public,
+        "client_keys" => known_clients
+      }))
+    end
+
+    File.open(key_dir.join("client_keys.yml"), "w+") do |f|
+      f.write(YAML.dump({
+        "private_key" => client_private, "public_key" => client_public,
+        "server_public_key" => options[:server_public_key] || server_public
+      }))
+    end
+  end
+
+  describe "connectivity" do
+    def assert_message_timeout(client)
+      message = ServerEchoCommand.new("Hello Server").to_message
+      response_future = client.send_request(message)
+
+      assert_raises(Celluloid::TimeoutError) do
+        response_future.value(1).body
+      end
+    end
+
+    def assert_successful_message(client)
+      message = ServerEchoCommand.new("Hello Server").to_message
+      response_future = client.send_request(message)
+
+      assert_equal ["Hello Server"], response_future.value(2).body
+    end
+
+    it "configures CURVE security for encrypted server/client communication" do
+      set_up_encrypted(15000)
+
+      server = Pantry::Server.new
+      server.identity = "Encrypted Server"
+      server.run
+
+      client = Pantry::Client.new identity: "encrypted-client"
+      client.run
+
+      assert_successful_message(client)
+    end
+
+    it "rejects clients who connect with the wrong server key" do
+      set_up_encrypted(15010, server_public_key: "invalid security token1234567890")
+
+      server = Pantry::Server.new
+      server.identity = "Encrypted Server"
+      server.run
+
+      client = Pantry::Client.new identity: "encrypted-client"
+      client.run
+
+      assert_message_timeout(client)
+    end
+
+    it "rejects a client whos public key is not known by the server" do
+      set_up_encrypted(15020, known_clients: ["some other client here1234567890"])
+
+      server = Pantry::Server.new
+      server.identity = "Encrypted Server"
+      server.run
+
+      client = Pantry::Client.new identity: "encrypted-client"
+      client.run
+
+      assert_message_timeout(client)
+    end
+
+  end
+
+  describe "requesting new client keys" do
+
+    mock_ui!
+
+    it "returns a new set of client keys as requested" do
+      set_up_encrypted(15030)
+
+      server = Pantry::Server.new
+      server.identity = "Encrypted Server"
+      server.run
+
+      cli = Pantry::CLI.new(
+        ["client:create"],
+        identity: "encrypted-client"
+      )
+      cli.run
+
+      assert_match /server_public_key/, stdout
+      assert_match /public_key/, stdout
+      assert_match /private_key/, stdout
+    end
+
+  end
+
+end