clusterfsck 0.1.5.0

data/spec/lib/clusterfsck/commands/override_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'commander'
+require 'clusterfsck/cli'
+
+module ClusterFsck::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
+      ClusterFsck::Reader.should_receive(:new).with(args.first, cluster_fsck_env: 'test').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/clusterfsck/configuration_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module ClusterFsck
+  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/clusterfsck/credential_grabber_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module ClusterFsck
+
+  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(:env_credentials) do
+      {
+          access_key_id: 'env_access_key',
+          secret_access_key: 'env_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 ~/.clusterfsck" 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 ~/.clusterfsck config and with or without a ~/.fog file" do
+      before do
+        credential_grabber.stub(:exists?).with(true)
+        ClusterFsck::CLUSTER_FSCK_CONFIG.should_receive(:[]).at_least(:once)
+          .with('aws_access_key_id').and_return(cf_credentials[:access_key_id])
+        ClusterFsck::CLUSTER_FSCK_CONFIG.should_receive(:[]).at_least(:once)
+          .with('aws_secret_access_key').and_return(cf_credentials[:secret_access_key])
+      end
+
+      it "should return the clusterfsck credentials" do
+        credential_grabber.find.should == cf_credentials
+      end
+      it "should return the credentials" do
+        credential_grabber.find.should == cf_credentials
+      end
+    end
+
+    describe "when there is both ENV vars and a ~/.fog file" do
+      before :each do
+        ENV.stub(:[]).with("AWS_ACCESS_KEY_ID").and_return(env_credentials[:access_key_id])
+        ENV.stub(:[]).with("AWS_SECRET_ACCESS_KEY").and_return(env_credentials[:secret_access_key])
+        File.stub(:expand_path).with(CredentialGrabber::FOG_PATH).and_return(CredentialGrabber::FOG_PATH)
+      end
+
+      it "should return the clusterfsck credentials" do
+        credential_grabber.find.should == env_credentials
+      end
+
+      it "should not look at expand_path because it short circuits first" do
+        credential_grabber.find
+        YAML.should_not_receive(:load_file)
+      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/clusterfsck/reader_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module ClusterFsck
+
+  describe Reader do
+    let(:cluster_fsck_env) { 'test' }
+    let(:key) { "test-key" }
+    let(:reader) { Reader.new(key) }
+    let(:mock_s3_obj) { mock(:s3_object, read: nil, :exists? => true) }
+
+
+    it "should set cluster_fsck_env" do
+      reader.cluster_fsck_env.should == cluster_fsck_env
+    end
+
+    describe "when there is a local override" do
+      let(:local_yaml) { YAML.dump(foo: true) }
+      let(:local_path) { "clusterfsck/#{cluster_fsck_env}/#{key}" }
+
+      before do
+        reader.send(:stored_object).should_not_receive(:exists?) #shouldn't even check for existence on the network
+        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/clusterfsck/s3_methods_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module ClusterFsck
+  class DummyClass
+    include S3Methods
+
+    def cluster_fsck_env
+      "test"
+    end
+  end
+
+  describe S3Methods do
+    let(:cluster_fsck_env) { 'test' }
+    let(:config_bucket) { ClusterFsck.config_bucket }
+    let(:key) { 'test_key' }
+    let(:dummy_instance) { DummyClass.new }
+
+    let(:mock_listing) { mock('obj', key: "#{cluster_fsck_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',
+                                    "#{cluster_fsck_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(cluster_fsck_env).and_return([mock_listing])
+      dummy_instance.all_files.should == [mock_listing.key]
+    end
+
+  end
+end

data/spec/lib/clusterfsck/writer_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module ClusterFsck
+
+  describe Writer do
+    let(:cluster_fsck_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),
+          :exists? => true
+      )
+      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(ClusterFsck::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(ClusterFsck::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,24 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+Dir["spec/support/**/*.rb"].each {|f| require File.expand_path(f)}
+
+require 'pry'
+require 'clusterfsck'
+
+
+# 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/cluster_fsck_env_setter.rb

@@ -0,0 +1,11 @@
+RSpec.configure do |config|
+  config.before(:suite) do
+    ENV['CLUSTER_FSCK_ENV'] = 'test'
+    #redefine constant warning when setting ClusterFsck::CLUSTER_FSCK_ENV constant here
+    def ClusterFsck.cluster_fsck_env
+      'test'
+    end
+    ENV['CLUSTER_FSCK_BUCKET'] = 'test'
+    ClusterFsck::CLUSTER_FSCK_BUCKET = 'test'
+  end
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: clusterfsck
+version: !ruby/object:Gem::Version
+  version: 0.1.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Topper Bowers, Brian Glusman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-19 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: 1.8.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.1.2
+- !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: random-word
+  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 based config getter/setter
+email:
+- topper@amicushq.com, brian@amicushq.com
+executables:
+- clusterfsck
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/clusterfsck
+- clusterfsck.gemspec
+- lib/clusterfsck.rb
+- lib/clusterfsck/cli.rb
+- lib/clusterfsck/commands/cluster_fsck_env_argument_parser.rb
+- lib/clusterfsck/commands/create.rb
+- lib/clusterfsck/commands/edit.rb
+- lib/clusterfsck/commands/environments.rb
+- lib/clusterfsck/commands/list.rb
+- lib/clusterfsck/commands/override.rb
+- lib/clusterfsck/commands/setup.rb
+- lib/clusterfsck/configuration.rb
+- lib/clusterfsck/credential_grabber.rb
+- lib/clusterfsck/reader.rb
+- lib/clusterfsck/s3_methods.rb
+- lib/clusterfsck/setup.rb
+- lib/clusterfsck/version.rb
+- lib/clusterfsck/writer.rb
+- spec/lib/clusterfsck/commands/amicus_env_argument_parser_spec.rb
+- spec/lib/clusterfsck/commands/create_spec.rb
+- spec/lib/clusterfsck/commands/edit_spec.rb
+- spec/lib/clusterfsck/commands/override_spec.rb
+- spec/lib/clusterfsck/configuration_spec.rb
+- spec/lib/clusterfsck/credential_grabber_spec.rb
+- spec/lib/clusterfsck/reader_spec.rb
+- spec/lib/clusterfsck/s3_methods_spec.rb
+- spec/lib/clusterfsck/writer_spec.rb
+- spec/spec_helper.rb
+- spec/support/cluster_fsck_env_setter.rb
+homepage: http://github.com/amicus/clusterfsck
+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: ClusterFsck manages configurable settings and sensitive login information
+  across any number of separate or related projects by reading writing simple values
+  or arrays/hashes of data to and from YAML files stored on Amazon S3. It also allows
+  centrally overriding or changing these on a per environment basis.
+test_files:
+- spec/lib/clusterfsck/commands/amicus_env_argument_parser_spec.rb
+- spec/lib/clusterfsck/commands/create_spec.rb
+- spec/lib/clusterfsck/commands/edit_spec.rb
+- spec/lib/clusterfsck/commands/override_spec.rb
+- spec/lib/clusterfsck/configuration_spec.rb
+- spec/lib/clusterfsck/credential_grabber_spec.rb
+- spec/lib/clusterfsck/reader_spec.rb
+- spec/lib/clusterfsck/s3_methods_spec.rb
+- spec/lib/clusterfsck/writer_spec.rb
+- spec/spec_helper.rb
+- spec/support/cluster_fsck_env_setter.rb