clustr 0.0.1

data/lib/clustr/node.rb

@@ -0,0 +1,33 @@
+module Clustr
+  # Represents a single node within a cluster. Note that
+  # the physical entity represented by this node may occur
+  # several times in other {Cluster}.
+  class Node
+
+    attr_reader :id, :properties, :created
+
+    # Creates a new {Node}, taking a unique identifier
+    # for the node within the {Cluster} and a set of optional,
+    # properties to further describe or provide additional
+    # information about the node.
+    #
+    # @param [mixed] id of the node within the cluster.
+    # @param [hash] properties to set for this node.
+    def initialize(id, properties = {})
+      @id = id
+      @created = Time.now.to_i
+      @properties = properties
+    end
+
+    # Retrieves a specific key from the property set that
+    # accompanies this node.
+    #
+    # @param [string] key of the property value to retrieve.
+    #
+    # @return [mixed] the corresponding value for the property key.
+    def [](key)
+      properties[key.to_s]
+    end
+
+  end
+end

data/lib/clustr/node_collection.rb

@@ -0,0 +1,8 @@
+module Clustr
+  # Represents a collection of {Node} instances. This class
+  # extends Hash to provide methods to access the collection.
+  # Each key within the collection represents a Nodes unique
+  # identifier within the cluster it is among.
+  class NodeCollection < Hash
+  end
+end

data/lib/clustr/version.rb

@@ -0,0 +1,4 @@
+module Clustr
+  # Version number of the Clustr gem
+  VERSION = "0.0.1"
+end

data/lib/clustr.rb

@@ -0,0 +1,69 @@
+require "aws-sdk"
+
+require "clustr/version"
+require "clustr/config"
+
+require "clustr/cluster_collection"
+require "clustr/cluster"
+
+require "clustr/node_collection"
+require "clustr/node"
+
+require "clustr/adapter"
+
+# This gem uses Amazon SimpleDB and other adapters, to track
+# namespaced attributes for instances that need to cluster together.
+# It provides a simple CLI which can be used in conjunction with other
+# shell commands. See examples/ for example Cloudformation Templates.
+module Clustr
+
+  # Provides classes with the ability to store messages for consumption
+  # elsewhere within the application. Typically via the CLI.
+  #
+  # @example Including and using the {Clustr::Message} module.
+  #   class Foo
+  #     include Clustr::Message
+  #     def initialize
+  #       message "The class has been initialized!", :type => :ok
+  #     end
+  #   end
+  module Message
+
+    attr :messages
+    attr_reader :message_proc
+
+    # Binds a message handler to proc a block when a message
+    # is added to the messages array.
+    #
+    # @param [Proc] message_proc the block to call when a message is added.
+    def message_handler(&message_proc)
+      @message_proc = message_proc
+    end
+
+    protected
+
+      # Places a new message into the messages array and optionally
+      # calls a block passed into the action handler.
+      #
+      # @param [String] msg to add to the messages array.
+      def message(msg, options={})
+        (@messages ||= []) << options.merge({:message => msg})
+        proc_with_message(messages.last, &@message_proc) if @message_proc
+      end
+
+      # Retrieve the underlying messages array or pass them
+      # through a block.
+      def messages(&block)
+        @messages.each { |m| proc_with_message(m, &block) } if block
+        return @messages
+      end
+
+    private
+
+      def proc_with_message(msg, &block)
+        block.call(msg[:message], msg)
+      end
+
+  end
+
+end

data/spec/clustr/cluster_collection_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+require 'clustr/cluster'
+require 'clustr/cluster_collection'
+
+describe Clustr::ClusterCollection do
+
+  before { @cluster_collection = Clustr::ClusterCollection.new }
+
+  subject { @cluster_collection }
+
+  it { should respond_to(:[]) }
+  it { should be_a_kind_of(Hash) }
+  it { should be_empty }
+
+  describe "when cluster configurations are present" do
+    let(:configuration) {
+      {
+        "rabbitmq" => {
+          "key" => "b" * 10
+        }
+      }
+    }
+
+    before {
+      Clustr::Adapter.stub(:from_options) { nil }
+      @cluster_collection = Clustr::ClusterCollection.new configuration
+    }
+
+    subject { @cluster_collection }
+
+    it { should_not be_empty }
+    it { should include("rabbitmq") }
+
+    it "should return a cluster" do
+      expect(@cluster_collection["rabbitmq"]).to be_a(Clustr::Cluster)
+    end
+
+  end
+
+end

data/spec/clustr/cluster_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+require 'clustr/cluster'
+
+describe Clustr::Cluster do
+
+  let(:cluster_name) { "foobar" }
+
+  before do
+    Clustr::Adapter.stub(:from_options) { nil }
+    @cluster = Clustr::Cluster.new(cluster_name, {})
+  end
+
+  subject { @cluster }
+
+  it { should respond_to(:name) }
+  it { should respond_to(:members) }
+  it { should respond_to(:add) }
+  it { should respond_to(:nodes) }
+
+  it "should return the name of the cluster" do
+    expect(@cluster.name).to eq(cluster_name)
+  end
+
+end

data/spec/clustr/config/clusters_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+require "clustr/config"
+require "clustr/config/clusters"
+
+describe Clustr::Config::Clusters do
+
+  include FakeFS::SpecHelpers
+
+  before { @clusters = Clustr::Config::Clusters }
+
+  subject { @clusters }
+
+  it { should respond_to(:configured?) }
+  it { should respond_to(:configuration) }
+
+  describe "return value of configuration" do
+
+    describe "when no cluster configuration files are set" do
+
+      before {
+        Clustr::Config::Clusters.stub(:config_files) { [] }
+        @configuration = Clustr::Config::Clusters.configuration
+      }
+
+      subject { @configuration }
+
+      it { should be_a_kind_of(Hash) }
+
+      it { should be_empty }
+
+    end
+
+    describe "when cluster configuration is set" do
+
+      let(:service_name) { "a_service" }
+
+      let(:file_path) { "#{service_name}" }
+
+      let(:config_contents) {
+        {
+          "a_key" => "a_value",
+          "another_key" => "another_value"
+        }
+      }
+
+      before do
+        File.open(file_path, "wb") do |f|
+          config_contents.each do |k, v|
+            f.write "#{k}=#{v}\n"
+          end
+        end
+
+        Clustr::Config::Clusters.stub(:config_files) { [file_path] }
+        @configuration = Clustr::Config::Clusters.configuration
+      end
+
+      subject { @configuration }
+
+      it { should be_a_kind_of(Hash) }
+
+      it { should include(service_name) }
+
+      it { should_not be_empty }
+
+      it "should equal the file contents" do
+        expect(@configuration[service_name]).to eq(config_contents)
+      end
+
+      describe "when two cluster configuration files are set" do
+
+        let(:second_service_name) { "a_second_service" }
+
+        let(:second_file_path) { "#{second_service_name}" }
+
+        let(:second_config_contents) {
+          {
+            "foo" => "bar"
+          }
+        }
+
+        before do
+          File.open(second_file_path, "wb") do |f|
+            second_config_contents.each do |k, v|
+              f.write "#{k}=#{v}\n"
+            end
+          end
+
+          Clustr::Config::Clusters.stub(:config_files) { [file_path, second_file_path] }
+          @configuration = Clustr::Config::Clusters.configuration
+        end
+
+        subject { @configuration }
+
+        it { should be_a_kind_of(Hash) }
+
+        it { should include(service_name, second_service_name) }
+
+        it "should equal the second file contents" do
+          expect(@configuration[second_service_name]).to eq(second_config_contents)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/clustr/config_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Clustr::Config do
+
+  let(:test_data) { { :a => "a", :b => "b"} }
+
+  before(:each) { Clustr::Config(test_data) }
+
+  it "should be present" do
+    expect(subject).to_not be_nil
+  end
+
+  it "should accept new values" do
+    subject[:new_value] = true
+    expect(subject[:new_value]).to equal(true)
+  end
+
+  it "should modify existing values" do
+    subject[:a] = "a new value"
+    expect(subject[:a]).to_not equal(test_data[:a])
+  end
+
+  it "should retrieve a single value" do
+    expect(subject[:a]).to equal(test_data[:a])
+  end
+
+  it "should retrieve sets of values" do
+    subject.select(*test_data.keys).should == test_data
+  end
+
+  it "should return nothing for a non-existing value" do
+    expect(subject.select(:non_existing_key)).to be_empty
+  end
+
+  it "should delete a key" do
+    Clustr::Config.delete!(:a)
+    expect(subject.select(:a, :b)).to eq({:b => "b"})
+  end
+
+end

data/spec/clustr/log_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+require 'clustr/log'
+
+describe Clustr::Log do
+
+  it { Clustr::Log.should respond_to(:debug) }
+  it { Clustr::Log.should respond_to(:error) }
+  it { Clustr::Log.should respond_to(:info) }
+  it { Clustr::Log.should respond_to(:warn) }
+  it { Clustr::Log.should respond_to(:fatal) }
+  it { Clustr::Log.should respond_to(:ok) }
+
+  describe "return value of #format_msg" do
+
+    let(:severity) { "ERROR" }
+    let(:msg) { "This is a test message" }
+    let(:time) { Time.now }
+
+    it "should return a correctly formatted message" do
+      message = Clustr::Log.format_msg(severity, msg, time)
+      expected_message = "[#{time}] [#{severity}]: #{msg}\n"
+      expect(message).to eq(expected_message)
+    end
+
+  end
+end

data/spec/clustr/node_collection_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+require 'clustr/node_collection'
+
+describe Clustr::NodeCollection do
+
+  before { @node_collection = Clustr::NodeCollection.new }
+
+  subject { @node_collection }
+
+  it { should respond_to(:[]) }
+  it { should be_a_kind_of(Hash) }
+  it { should be_empty }
+
+  describe "when a node is present" do
+
+    let(:node) { build(:node) }
+
+    let(:node_id) { 123 }
+
+    before { @node_collection[node_id] = node }
+
+    it { should_not be_empty }
+    it { should include(node_id) }
+
+    it "should return the node" do
+      expect(@node_collection[node_id]).to eq node
+    end
+
+  end
+
+end

data/spec/clustr/node_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'clustr/node'
+
+describe Clustr::Node do
+
+  let(:node_id) { 123 }
+
+  let(:node_properties) { { "foo" => "bar" } }
+
+  let(:node_created) { Time.now.to_i }
+
+  before { @node = Clustr::Node.new(node_id, node_properties) }
+
+  subject { @node }
+
+  it { should respond_to(:id) }
+  it { should respond_to(:properties) }
+  it { should respond_to(:created) }
+  it { should respond_to(:[]) }
+
+  it "should have the correct id" do
+    expect(@node.id).to eq(node_id)
+  end
+
+  it "should have the correct properties" do
+    expect(@node.properties).to eq(node_properties)
+  end
+
+  it "should have the correct create time" do
+    expect(@node.created).to eq(node_created)
+  end
+
+  describe "return value of #[](key)" do
+
+    it "should return the correct property" do
+      expect(@node[node_properties.keys.first]).to eq(node_properties.values.first)
+    end
+
+  end
+
+end

data/spec/clustr/version_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Clustr do
+
+  it "should have a valid version number" do
+    expect(Gem::Version.correct?(Clustr::VERSION)).to eq(0)
+  end
+
+end

data/spec/factories/node.rb

@@ -0,0 +1,14 @@
+require 'faker'
+
+require 'clustr/node'
+
+FactoryGirl.define do
+  factory :node, :class => Clustr::Node do
+    ignore do
+      id Faker::Number.number(10)
+      properties :foo => "bar"
+    end
+
+    initialize_with { new id, properties }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'pp'
+require 'aws-sdk'
+require 'fakefs/spec_helpers'
+require 'factory_girl'
+require 'clustr'
+
+AWS.stub!
+
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
+FactoryGirl.find_definitions
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+end

data/spec/support/message_shared.rb

@@ -0,0 +1,54 @@
+shared_examples "a class that stores messages" do
+
+  let(:test_message) { "This is a test message" }
+  let(:test_options) { { :type => :ok } }
+
+  before do
+    subject.message(test_message, test_options)
+  end
+
+  it { should respond_to(:messages) }
+  it { should respond_to(:message) }
+
+  describe "return value of #messages" do
+    it "should return an array" do
+      expect(subject.messages).to be_a(Array)
+    end
+
+    it "should have a positive length" do
+      expect(subject.messages.length).to be > 0
+    end
+
+    it "should be an array of hashes" do
+      expect(subject.messages.first).to be_a(Hash)
+    end
+
+    it "should contain an array of hashed messages" do
+      expect(subject.messages.first[:message]).to eq(test_message)
+    end
+  end
+
+  describe "when #messages is called with a block" do
+
+    it "should call the block" do
+      expect { |b| subject.messages(&b) }.to yield_control.once
+    end
+
+    it "should yield the message elements" do
+      expected_options = test_options.merge(:message => test_message)
+      expect { |b| subject.messages(&b) }.to yield_with_args(test_message, expected_options)
+    end
+
+  end
+
+  describe "when a class has a message handler bound" do
+    it "should call the block when a message is added" do
+      expect { |b|
+        subject.message_handler &b
+        subject.message(test_message, test_options)
+        subject.message(test_message, test_options)
+      }.to yield_control.twice
+    end
+  end
+
+end