cluster-fuck 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+.DS_Store
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@cluster-fuck --create

data/Gemfile

@@ -0,0 +1,13 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in cluster-fuck.gemspec
+gemspec
+
+group :test do
+  gem 'guard-rspec'
+  gem 'rb-fsevent', '~> 0.9.1'
+  gem 'rake'
+  gem 'fakes3'
+  gem 'pry'
+  gem 'ci_reporter', '~> 1.7.3'
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Topper Bowers
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# Cluster::Fuck
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cluster-fuck'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cluster-fuck
+
+
+### setup your credential file
+If you are not on an EC2 instance then you should setup your ~/.cluster-fuck file with the followng yaml:
+
+```yaml
+:access_key_id: access_key
+:secret_access_key: secret_key
+```
+
+It will also look for a ~/.fog file with the following syntax
+
+```yaml
+:default:
+  :aws_access_key_id: access_key
+  :aws_secret_access_key: secret_key
+```
+
+Otherwise, it expects you to be on an EC2 instance and not have to setup credentials.
+
+
+## Usage
+
+```ruby
+reader = ClusterFuck::Reader.new
+reader[:stripe][:api_key] loads "config_bucket/amicus_env/stripe and returns the api_key from the hash
+```
+The ClusterFuck::Reader instance will automatically load the configuration for 
+the environment stored in the AMICUS_ENV environment variable on the host.
+
+1. Fork it
+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,10 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+begin
+  require 'ci/reporter/rake/rspec'
+rescue LoadError => ex
+  puts "Failed to load the ci_reporter gem. Make sure it is available in your loadpaths"
+end

data/bin/clusterfuck

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require 'commander/import'
+
+$LOAD_PATH.unshift(File.join(File.expand_path(File.dirname(__FILE__)), "../lib"))
+require "cluster-fuck/cli"
+
+program :version, ClusterFuck::VERSION
+program :description, 'Amicus environment-aware configuration manager'
+
+#TODO: (topper) - fill in the help stuff
+
+command :edit do |c|
+  c.syntax = 'clusterfuck edit [options]'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  c.option '--force', 'force edit even if local file present'
+  c.when_called ClusterFuck::Commands::Edit, :run_command
+end
+
+command :create do |c|
+  c.syntax = 'clusterfuck create [options]'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  #c.option '--some-switch', 'Some switch that does something'
+  c.when_called ClusterFuck::Commands::Create, :run_command
+end
+
+command :list do |c|
+  c.syntax = 'clusterfuck list'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  #c.option '--some-switch', 'Some switch that does something'
+  c.when_called ClusterFuck::Commands::List, :run_command
+end
+
+command :override do |c|
+  c.syntax = 'clusterfuck override [options]'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  #c.option '--some-switch', 'Some switch that does something'
+  c.when_called ClusterFuck::Commands::Override, :run_command
+end

data/cluster-fuck.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cluster-fuck/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cluster-fuck"
+  gem.version       = ClusterFuck::VERSION
+  gem.authors       = ["Topper Bowers"]
+  gem.email         = ["topper@amicushq.com"]
+  gem.description   = "cluster-aware S3 and ZK based config getter/setter"
+  gem.summary       = ""
+  gem.homepage      = ""
+
+  gem.add_dependency "aws-sdk"
+  gem.add_dependency "hashie"
+  gem.add_dependency "commander", "~> 4.1.0"
+
+  gem.add_development_dependency "rspec"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/cluster-fuck.rb

@@ -0,0 +1,25 @@
+require "cluster-fuck/version"
+
+module ClusterFuck
+  CONFIG_BUCKET = 'amicus-config'
+  AMICUS_ENV = ENV['AMICUS_ENV'] || 'development'
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
+
+end
+
+require 'aws-sdk'
+require 'hashie'
+require 'yaml'
+
+require 'cluster-fuck/credential_grabber'
+require 'cluster-fuck/s3_methods'
+require 'cluster-fuck/configuration'
+require 'cluster-fuck/reader'
+require 'cluster-fuck/writer'

data/lib/cluster-fuck/cli.rb

@@ -0,0 +1,5 @@
+require_relative "../cluster-fuck"
+require_relative "commands/edit"
+require_relative "commands/create"
+require_relative "commands/list"
+require_relative "commands/override"

data/lib/cluster-fuck/commands/create.rb

@@ -0,0 +1,20 @@
+require 'commander'
+require_relative "edit"
+
+module ClusterFuck
+  module Commands
+    class Create
+      include ClusterFuck::S3Methods
+
+      attr_reader :key
+      def run_command(args, options = {})
+        @key = args.first
+        obj = s3_object(key)
+        raise ConflictError, "#{key} already exists!" if obj.exists?
+        obj.write('')
+        Edit.new.run_command(args)
+      end
+
+    end
+  end
+end

data/lib/cluster-fuck/commands/edit.rb

@@ -0,0 +1,28 @@
+require 'commander'
+
+module ClusterFuck
+  module Commands
+    class Edit
+      include Commander::UI
+
+      attr_reader :key, :options
+      def run_command(args, options = Hashie::Mash.new)
+        @key = args.first
+        @options = options
+        raise ArgumentError, "File #{key} is overridden locally! use --force to force" if reader.has_local_override? and !options.force
+
+        new_yaml = ask_editor(YAML.dump(reader.read(remote_only: true).to_hash))
+        writer.set(Configuration.from_yaml(new_yaml), reader.version_count)
+      end
+
+      def writer
+        @writer ||= ClusterFuck::Writer.new(key)
+      end
+
+      def reader
+        @reader ||= ClusterFuck::Reader.new(key)
+      end
+
+    end
+  end
+end

data/lib/cluster-fuck/commands/list.rb

@@ -0,0 +1,14 @@
+require 'commander'
+
+module ClusterFuck
+  module Commands
+    class List
+      include ClusterFuck::S3Methods
+
+      def run_command(args, options = {})
+        $stdout.puts(all_files.join("\n"))
+      end
+
+    end
+  end
+end

data/lib/cluster-fuck/commands/override.rb

@@ -0,0 +1,27 @@
+require 'commander'
+require 'fileutils'
+
+module ClusterFuck
+  module Commands
+    class Override
+      include ClusterFuck::S3Methods
+
+      attr_reader :key
+      def run_command(args, options = {})
+        @key = args.first
+        contents = reader.read(remote_only: true)
+        FileUtils.mkdir_p(File.dirname(reader.local_override_path))
+        File.open(reader.local_override_path, "w") do |f|
+          f << contents.to_yaml
+        end
+        $stdout.puts("wrote #{reader.local_override_path} with contents of #{reader.full_s3_path(key)}")
+      end
+
+    private
+      def reader
+        @reader ||= ClusterFuck::Reader.new(key)
+      end
+
+    end
+  end
+end

data/lib/cluster-fuck/configuration.rb

@@ -0,0 +1,13 @@
+module ClusterFuck
+  class Configuration < Hashie::Mash
+
+    def self.from_yaml(yaml)
+      new(YAML.load(yaml))
+    end
+
+    def to_yaml
+      YAML.dump(to_hash)
+    end
+
+  end
+end

data/lib/cluster-fuck/credential_grabber.rb

@@ -0,0 +1,39 @@
+module ClusterFuck
+
+  class CredentialGrabber
+    FOG_PATH = "~/.fog"
+    CF_PATH = "~/.cluster-fuck"
+
+    def self.find
+      new.find
+    end
+
+    def find
+      from_cluster_fuck_file || from_fog_file
+    end
+
+    def from_fog_file
+      if exists?(File.expand_path(FOG_PATH))
+        fog_credentials = YAML.load_file(File.expand_path(FOG_PATH))
+        {
+            access_key_id: fog_credentials[:default][:aws_access_key_id],
+            secret_access_key: fog_credentials[:default][:aws_secret_access_key],
+        }
+      end
+    end
+
+    def from_cluster_fuck_file
+      if exists?(CF_PATH)
+        YAML.load_file(CF_PATH)
+      end
+    end
+
+  private
+    def exists?(path)
+      File.exist?(path)
+    end
+
+  end
+
+
+end

data/lib/cluster-fuck/reader.rb

@@ -0,0 +1,44 @@
+module ClusterFuck
+  class Reader
+    include S3Methods
+
+    LOCAL_OVERRIDE_DIR = "cluster-fuck"
+
+    attr_reader :amicus_env, :key, :version_count
+    def initialize(key, opts={})
+      @key = key
+      @amicus_env = opts[:amicus_env] || ClusterFuck::AMICUS_ENV
+      @ignore_local = opts[:ignore_local]
+    end
+
+    def read(opts = {})
+      yaml = data_for_key(opts)
+      if yaml
+        @version_count = stored_object.versions.count unless has_local_override?
+        Configuration.from_yaml(yaml)
+      end
+    end
+
+    def has_local_override?
+      File.exists?(local_override_path)
+    end
+
+    def local_override_path
+      File.join(LOCAL_OVERRIDE_DIR, full_s3_path(key))
+    end
+
+  private
+    def data_for_key(opts = {})
+      if has_local_override? and !opts[:remote_only]
+        File.read(local_override_path)
+      else
+        stored_object.read
+      end
+    end
+
+    def stored_object
+      @stored_object ||= s3_object(key)
+    end
+
+  end
+end

data/lib/cluster-fuck/s3_methods.rb

@@ -0,0 +1,42 @@
+module ClusterFuck
+  module S3Methods
+
+    class ConflictError < StandardError; end
+
+    def s3_object(object_name)
+      bucket.objects[full_s3_path(object_name)]
+    end
+
+    def bucket
+      @bucket ||= s3.buckets[CONFIG_BUCKET]
+    end
+
+    def credentials
+      @credentials ||= CredentialGrabber.find
+    end
+
+    def s3
+      if credentials
+        AWS::S3.new(credentials) #could be nil, especially if on EC2
+      else
+        AWS::S3.new
+      end
+    end
+
+    def all_files
+      bucket.objects.with_prefix(amicus_env).collect(&:key)
+    end
+
+    def full_s3_path(key)
+      "#{amicus_env}/#{key}"
+    end
+
+  protected
+
+
+    def amicus_env
+      AMICUS_ENV
+    end
+
+  end
+end

data/lib/cluster-fuck/version.rb

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

data/lib/cluster-fuck/writer.rb

@@ -0,0 +1,30 @@
+module ClusterFuck
+  class Writer
+    include S3Methods
+
+    attr_reader :amicus_env, :key
+    def initialize(key, opts = {})
+      @key = key
+      @amicus_env = opts[:amicus_env] || ClusterFuck::AMICUS_ENV
+    end
+
+    #todo, thread safety and process safety please
+    def set(val, version_count = nil)
+      raise_unless_version_count_is_good(version_count)
+      stored_object.write(val.to_yaml)
+      raise_unless_version_count_is_good(version_count + 1) if version_count
+    end
+
+    def raise_unless_version_count_is_good(version_count)
+      if version_count and stored_object.versions.count > version_count
+        raise ConflictError, "File #{key} changed underneath you, version_count expected to be #{version_count} but was #{stored_object.versions.count}"
+      end
+    end
+
+    def stored_object
+      @stored_object ||= s3_object(key)
+    end
+
+
+  end
+end

data/spec/lib/cluster-fuck/commands/create_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'commander'
+require 'cluster-fuck/cli'
+
+module ClusterFuck::Commands
+  describe Create do
+
+    let(:amicus_env) { "test" }
+    let(:args) { ["test-key"] }
+    let(:mock_s3_object) do
+      mock("s3_obj",
+        :"exists?" => false,
+        :write => true
+      )
+    end
+
+    before do
+      ClusterFuck::Commands::Edit.any_instance.stub(:run_command).and_return(true)
+      subject.stub(:s3_object).and_return(mock_s3_object)
+    end
+
+    it "should create the file" do
+      mock_s3_object.should_receive(:write).with("")
+      subject.run_command(args)
+    end
+
+    it "should open the editor with the file" do
+      ClusterFuck::Commands::Edit.any_instance.should_receive(:run_command).with(args).and_return(true)
+      subject.run_command(args)
+    end
+
+    it "should error and not write if the file already exists" do
+      mock_s3_object.stub(:exists?).and_return(true)
+      mock_s3_object.should_not_receive(:write)
+      ->() { subject.run_command(args) }.should raise_error(ClusterFuck::S3Methods::ConflictError)
+    end
+
+  end
+
+
+end

data/spec/lib/cluster-fuck/commands/edit_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'commander'
+require 'cluster-fuck/cli'
+
+module ClusterFuck::Commands
+  describe Edit do
+    let(:key) { "test-key" }
+    let(:mock_writer) { mock("writer", set: true) }
+
+    let(:dummy_val) do
+      {
+          key => {
+            'test' => true
+          }
+      }
+    end
+
+    let(:dummy_yaml) { YAML.dump(dummy_val) }
+    let(:mock_s3_obj) do
+      mock(:s3_object, {
+          read: dummy_yaml,
+          versions: mock('versions', count: 3)
+      })
+    end
+
+    before do
+      ClusterFuck::Reader.any_instance.stub(:s3_object).and_return(mock_s3_obj)
+    end
+
+    describe "with a key" do
+      let(:args) { [key] }
+
+      it "should open the yaml version of the key in an editor" do
+        subject.should_receive(:ask_editor).with(dummy_yaml).and_return(dummy_yaml)
+        subject.stub(:writer).and_return(mock_writer)
+        mock_writer.should_receive(:set).with(dummy_val, mock_s3_obj.versions.count).once
+
+        subject.run_command(args)
+      end
+
+      it "should error when it is locally overriden" do
+        subject.reader.stub(:has_local_override?).and_return(true)
+        ->() { subject.run_command(args) }.should raise_error(ArgumentError)
+      end
+
+    end
+  end
+end

data/spec/lib/cluster-fuck/commands/override_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'commander'
+require 'cluster-fuck/cli'
+
+module ClusterFuck::Commands
+  describe Override do
+    let(:mock_reader) do
+      mock("reader",
+           read: "contents",
+           local_override_path: "/path/to/nowhere",
+           full_s3_path: "test/test-key"
+      )
+    end
+    let(:args) { ["test-key"] }
+
+    before do
+      ClusterFuck::Reader.should_receive(:new).with(args.first).and_return(mock_reader)
+    end
+
+    it "should read the remote contents and write the local contents" do
+      FileUtils.should_receive(:mkdir_p).with(File.dirname(mock_reader.local_override_path))
+      File.should_receive(:open).with(mock_reader.local_override_path, "w")
+      subject.run_command(args)
+    end
+  end
+end

data/spec/lib/cluster-fuck/configuration_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module ClusterFuck
+  describe Configuration do
+
+    it "should be a mash" do
+      Configuration.new.should be_a(Hashie::Mash)
+    end
+
+    it "should load from yaml" do
+      yaml = YAML.dump({foo: 'bar'})
+      Configuration.from_yaml(yaml)[:foo].should == 'bar'
+    end
+
+    # TODO (topper): this isn't explicitly testing the right thing
+    # but it does *actually* test the right thing
+    it "should dump to yaml" do
+      hsh = {'foo' => 'bar'}
+      Configuration.new(hsh).to_yaml.should == YAML.dump(hsh)
+    end
+
+  end
+
+
+end

data/spec/lib/cluster-fuck/credential_grabber_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module ClusterFuck
+
+  describe CredentialGrabber do
+    let(:credential_grabber) { CredentialGrabber.new }
+
+    before do
+      credential_grabber.stub(:exists?).and_return(false)
+    end
+
+    it "should have a singleton find" do
+      fake_credential_grabber = mock(:credential_grabber)
+      fake_credential_grabber.should_receive(:find).and_return nil
+      CredentialGrabber.should_receive(:new).and_return(fake_credential_grabber)
+      CredentialGrabber.find
+    end
+
+    let(:cf_credentials) do
+      {
+          access_key_id: 'cf_access_key',
+          secret_access_key: 'cf_secret_key'
+      }
+    end
+
+    let(:fog_credentials) do
+      {
+        default: {
+          aws_access_key_id: 'fog_access_key',
+          aws_secret_access_key: 'fog_secret_key'
+        }
+      }
+    end
+
+    describe "when there is a ~/.fog file but no ~/.cluster-fuck" do
+      before do
+        File.stub(:expand_path).with(CredentialGrabber::FOG_PATH).and_return(CredentialGrabber::FOG_PATH)
+        credential_grabber.should_receive(:exists?).with(CredentialGrabber::FOG_PATH).and_return(true)
+        YAML.should_receive(:load_file).with(CredentialGrabber::FOG_PATH).and_return(fog_credentials)
+      end
+
+      it "should return the credentials" do
+        credential_grabber.find.should == {
+            access_key_id: 'fog_access_key',
+            secret_access_key: 'fog_secret_key',
+        }
+      end
+    end
+
+    describe "when there is a ~/.cluster-fuck file and no ~/.fog file" do
+      before do
+        credential_grabber.should_receive(:exists?).with(CredentialGrabber::CF_PATH).and_return(true)
+        YAML.should_receive(:load_file).with(CredentialGrabber::CF_PATH).and_return(cf_credentials)
+      end
+
+      it "should return the credentials" do
+        credential_grabber.find.should == cf_credentials
+      end
+    end
+
+    describe "when there is both a ~/.cluster-fuck and a ~/.fog file" do
+      before do
+        credential_grabber.should_receive(:exists?).and_return(true)
+        YAML.should_receive(:load_file).with(CredentialGrabber::CF_PATH).and_return(cf_credentials)
+      end
+
+      it "should return the cluster-fuck credentials" do
+        credential_grabber.find.should == cf_credentials
+      end
+    end
+
+    describe "when there are no credential files" do
+
+      it "should return nil" do
+        credential_grabber.find.should be_nil
+      end
+
+    end
+
+  end
+end

data/spec/lib/cluster-fuck/reader_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module ClusterFuck
+
+  describe Reader do
+    let(:amicus_env) { 'test' }
+    let(:key) { "test-key" }
+    let(:reader) { Reader.new(key) }
+    let(:mock_s3_obj) { mock(:s3_object, read: nil) }
+
+
+    it "should set amicus_env" do
+      reader.amicus_env.should == amicus_env
+    end
+
+    describe "when there is a local override" do
+      let(:local_yaml) { YAML.dump(foo: true) }
+      let(:local_path) { "cluster-fuck/#{amicus_env}/#{key}" }
+
+      before do
+        File.should_receive(:exists?).at_least(1).times.with(local_path).and_return(true)
+        File.stub(:read).with(local_path).and_return(local_yaml)
+      end
+
+      it "should #has_local_override?" do
+        reader.has_local_override?.should be_true
+      end
+
+      it "should use the local override when it exists" do
+        reader.read.should == Configuration.from_yaml(local_yaml)
+      end
+    end
+
+    describe "#read" do
+      let(:version_count) { 3 }
+
+      before do
+        mock_s3_obj.stub({
+            read: YAML.dump({
+              foo: 'bar'
+            }),
+            versions: mock('versions', count: version_count)
+        })
+        reader.stub(:s3_object).with(key).and_return(mock_s3_obj)
+        reader.stub(:s3_object).with(key.to_sym).and_return(mock_s3_obj)
+      end
+
+      it "should load the remote file and yaml parse it" do
+        reader.read['foo'].should == 'bar'
+      end
+
+      it "should set the version count" do
+        reader.read
+        reader.version_count.should == version_count
+      end
+
+    end
+  end
+end

data/spec/lib/cluster-fuck/s3_methods_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module ClusterFuck
+  class DummyClass
+    include S3Methods
+  end
+
+  describe S3Methods do
+    let(:amicus_env) { 'test' }
+    let(:config_bucket) { ClusterFuck::CONFIG_BUCKET }
+    let(:key) { 'test_key' }
+    let(:dummy_instance) { DummyClass.new }
+
+    let(:mock_listing) { mock('obj', key: "#{amicus_env}/#{key}") }
+    let(:bucket_objects) { mock('bucket_objects', with_prefix: [mock_listing]) }
+    let(:mock_bucket) { mock(:bucket, objects: bucket_objects) }
+
+    before do
+      DummyClass.any_instance.stub(:bucket).and_return(mock_bucket)
+    end
+
+    it "should qualify the keys it gets with the namespace" do
+      mock_bucket.stub(:objects) { { key => 'fail',
+                                    "#{amicus_env}/#{key}" => 'pass'} }
+      dummy_instance.stub(:bucket) { mock_bucket }
+      dummy_instance.s3_object(key).should == 'pass'
+    end
+
+    it "should enumerate all files with the prefix" do
+      bucket_objects.should_receive(:with_prefix).with(amicus_env).and_return([mock_listing])
+      dummy_instance.all_files.should == [mock_listing.key]
+    end
+
+  end
+end

data/spec/lib/cluster-fuck/writer_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module ClusterFuck
+
+  describe Writer do
+    let(:amicus_env) { 'development' }
+    let(:key) { 'tester' }
+    let(:reader) { Reader.new(key) }
+    let(:mock_s3_obj) { mock(:s3_object, read: nil) }
+    let(:writer) { Writer.new(key) }
+    let(:initial_version_count) { 3 }
+
+    before do
+      mock_s3_obj.stub(
+          read: YAML.dump({
+            foo: 'bar',
+            deep: {
+              works: 'too',
+              even: 'here'
+            }
+          }),
+          versions: mock('versions', count: initial_version_count)
+      )
+      Reader.any_instance.stub(:s3_object).with("#{key}").and_return(mock_s3_obj)
+      writer.stub(:s3_object).and_return(mock_s3_obj)
+    end
+
+    describe "#set" do
+      it "should write the configuration to the file" do
+        writer.should_receive(:s3_object).with(key).and_return(mock_s3_obj)
+
+        mock_s3_obj.should_receive(:write).with(YAML.dump({
+                  'deep' => {
+                    'even' => 'changed'
+                  }
+        }))
+
+        do_write
+      end
+
+      describe "with version counts" do
+
+        it "should work normally when nothing has changed underneath" do
+          mock_write
+          mock_s3_obj.versions.stub(:count).and_return(initial_version_count, (initial_version_count + 1))
+
+          do_write
+        end
+
+        it "should raise an error and not write when it has changed before the set" do
+          mock_s3_obj.should_not_receive(:write)
+          mock_s3_obj.versions.stub(:count).and_return(initial_version_count + 1)
+
+          ->() { do_write }.should raise_error(ClusterFuck::S3Methods::ConflictError)
+        end
+
+        it "should raise an error if the version count has hopped AFTER our write" do
+          mock_write
+          mock_s3_obj.versions.stub(:count).and_return(initial_version_count, (initial_version_count + 2))
+
+          ->() { do_write }.should raise_error(ClusterFuck::S3Methods::ConflictError)
+        end
+
+        def mock_write
+          mock_s3_obj.should_receive(:write).with(YAML.dump({
+                    'deep' => {
+                      'even' => 'changed'
+                    }
+          }))
+        end
+      end
+
+      def do_write
+        writer.set(Configuration.new({
+                    deep: {
+                        even: 'changed'
+                    }
+        }), initial_version_count)
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'pry'
+require 'cluster-fuck'
+
+Dir["spec/support/**/*.rb"].each {|f| require File.expand_path(f)}
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/amicus_env_setter.rb

@@ -0,0 +1,6 @@
+RSpec.configure do |config|
+  config.before(:suite) do
+    ENV['AMICUS_ENV'] = 'test'
+    ClusterFuck::AMICUS_ENV = 'test'
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: cluster-fuck
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Topper Bowers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: cluster-aware S3 and ZK based config getter/setter
+email:
+- topper@amicushq.com
+executables:
+- clusterfuck
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/clusterfuck
+- cluster-fuck.gemspec
+- lib/cluster-fuck.rb
+- lib/cluster-fuck/cli.rb
+- lib/cluster-fuck/commands/create.rb
+- lib/cluster-fuck/commands/edit.rb
+- lib/cluster-fuck/commands/list.rb
+- lib/cluster-fuck/commands/override.rb
+- lib/cluster-fuck/configuration.rb
+- lib/cluster-fuck/credential_grabber.rb
+- lib/cluster-fuck/reader.rb
+- lib/cluster-fuck/s3_methods.rb
+- lib/cluster-fuck/version.rb
+- lib/cluster-fuck/writer.rb
+- spec/lib/cluster-fuck/commands/create_spec.rb
+- spec/lib/cluster-fuck/commands/edit_spec.rb
+- spec/lib/cluster-fuck/commands/override_spec.rb
+- spec/lib/cluster-fuck/configuration_spec.rb
+- spec/lib/cluster-fuck/credential_grabber_spec.rb
+- spec/lib/cluster-fuck/reader_spec.rb
+- spec/lib/cluster-fuck/s3_methods_spec.rb
+- spec/lib/cluster-fuck/writer_spec.rb
+- spec/spec_helper.rb
+- spec/support/amicus_env_setter.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- spec/lib/cluster-fuck/commands/create_spec.rb
+- spec/lib/cluster-fuck/commands/edit_spec.rb
+- spec/lib/cluster-fuck/commands/override_spec.rb
+- spec/lib/cluster-fuck/configuration_spec.rb
+- spec/lib/cluster-fuck/credential_grabber_spec.rb
+- spec/lib/cluster-fuck/reader_spec.rb
+- spec/lib/cluster-fuck/s3_methods_spec.rb
+- spec/lib/cluster-fuck/writer_spec.rb
+- spec/spec_helper.rb
+- spec/support/amicus_env_setter.rb