manic_baker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d67391367a32c3bdfb8243523236a30b1c4f8ea6
+  data.tar.gz: 04c45791867835639f37d6b9b623e99438da11a9
+SHA512:
+  metadata.gz: 9f3ccd681d950e38144143fd6423773d194072fb98c944faa255fc1602f59c2db61ee59034391960d3aeec0ba1d10ce1b85382c125e4ad1d0f1ca44e40cb8942
+  data.tar.gz: daad125b612a6df9eed43fda309f5c6d8fee4ae50a8f6214d1fb90649bd6fd22d09ca5ab58c80a9fc8bc7f015790c7bce3f6819ed72dcaa2d536fb777b6225d7

data/.gitignore

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

data/.rspec

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

data/.ruby-gemset

@@ -0,0 +1 @@
+manic_baker

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p195

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - 2.0.0
+script: script/ci.sh

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in manic_baker.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+guard :rspec, {:env => {"JOYENT_USERNAME" => "docteats"} } do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Doc Ritezel
+
+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,89 @@
+# Manic Baker
+
+[![Build Status](https://travis-ci.org/minifast/manic_baker.png)](https://travis-ci.org/minifast/manic_baker) [![Code Climate](https://codeclimate.com/github/minifast/manic_baker.png)](https://codeclimate.com/github/minifast/manic_baker)
+
+>  Note: Most of the functionality in this repository is
+>        better implemented in Vagrant or Knife.
+
+Manic Baker lets you do all the stuff you want for a full
+continuous deployment cycle on Joyent:
+
+1. Spin up a new Joyent base image
+1. Bootstrap the new node into Chefable condition
+1. Parbake your application code
+1. Run your runlist using soloist
+1. Snapshot the Joyent instance
+1. Scale instances up or down using a snapshot id
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'manic_baker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install manic_baker
+
+## Usage
+
+Manic Baker has a totally baller command line interface.
+
+    $ manic parbake 1d6af-is-that-a-sha
+
+        start  base image '0000-2bad-54e5-a-ba7'
+          run  bootstrap.sh
+        rsync  copying this directory to /opt/app
+         chef  not_sql::default
+         chef  your_awesome_application::default
+         chef  runit::your_awesome_application
+     snapshot  created with id '1d6af-is-that-a-sha'
+         stop  build complete
+
+    $ manic parbake 1d6af-is-that-a-sha
+
+          oop  snapshot '1d6af-is-that-a-sha' already exists
+
+    $ manic boot no-snapshot-called-this
+
+          oop  snapshot 'no-snapshot-called-this' not found
+
+    $ manic boot 1d6af-is-that-a-sha
+
+        start  snapshot '1d6af-is-that-a-sha' booting
+      waiting  ...
+        bound  instance is now available at 192.168.0.1
+
+    $ manic boot 1d6af-is-that-a-sha
+
+         nope  an instance of '1d6af-is-that-a-sha' is running
+
+    $ manic boot --plz --scale=2 1d6af-is-that-a-sha
+
+         fine  whatever
+        panic  running over instance at 192.168.0.1
+      waiting  ...
+         done  it was looking at me funny
+        start  snapshot '1d6af-is-that-a-sha' booting
+      waiting  ...
+      scale.1  instance is now available at 192.168.0.2
+      scale.2  instance is now available at 192.168.0.3
+
+    $ manic panic 1d6af-is-that-a-sha
+
+        panic  slandering instance at 192.168.0.2
+        panic  posting pictures of instance at 192.168.0.3
+         done  their lives are ruined for a reason
+
+## Contributing
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. If you are making changes in the lib/ directory, add tests.
+1. Commit your changes (`git commit -am 'Add some feature'`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Create new Pull Request

data/bin/manic

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path("../../lib", __FILE__)
+require "manic_baker"
+ManicBaker::Cli.start

data/config/locales/en.yml

@@ -0,0 +1,52 @@
+boring:
+  - ugh
+  - hurry uuuuuup
+  - i'm getting old
+  - this is seriously slower than my housekeeper?
+  - really?
+  - guys this is not my jam
+  - have you seen my phone.
+  - i don't really have a tumblr anymore
+success:
+  start:
+    - making friends with %s
+    - going to music festival with %s
+    - drinking sangria and watching boys with %s
+    - going to the club with %s
+  bootstrap:
+    - getting french manicure with %s
+    - watching project runway with %s
+    - writing gilmore girls fanfics starring %s
+  chef:
+    - making quesadillas with %s
+  stop:
+    - slandering %s
+    - running over %s
+    - snapchatting naked pictures of %s
+    - stealing boyfriend of %s
+    - stealing girlfriend of %s
+  terminate:
+    - its life is over for a reason
+    - it just couldn't hang
+    - i feel sorry for it but not really?
+  snapshot:
+    - omg totally tagging %s cuz we were in %s
+  ssh:
+    - just so happy to hang with %s
+    - going to a movie with %s tmz
+failure:
+  start:
+    - can't even stand the sight of %s at lunch
+    - ignoring texts from %s
+    - deleting %s from facebook
+  bootstrap:
+    - cannot change anything about %s
+  chef:
+    - totally got food poisoning from %s
+  stop:
+    - cannot even stand to be around %s
+  terminate:
+    - ugh why are some people just bad
+  ssh:
+    - so worried about %s
+    - does anyone know why %s isn't answering?

data/lib/manic_baker.rb

@@ -0,0 +1,2 @@
+require "manic_baker/version"
+require "manic_baker/cli"

data/lib/manic_baker/cli.rb

@@ -0,0 +1,177 @@
+require "librarian/chef/cli"
+require "thor"
+require "thor/shell/mean"
+require "fog"
+require "manic_baker/config"
+require "manic_baker/remote_config"
+require "soloist/spotlight"
+require "soloist/remote"
+
+module ManicBaker
+  class Cli < Thor
+    include Thor::Shell::Mean
+
+    desc "launch", "Launch a new instance, Alana"
+    def launch(dataset = nil)
+      unless dataset.nil?
+        config.dataset = dataset
+        config.save
+      end
+
+      check_dataset
+      check_no_servers
+
+      say_message_for(:start, :success, config.dataset)
+      joyent.servers.create(config.to_hash)
+      say_waiting_until { dataset_servers.first.state == "running" }
+      say_message_for(:start, :success, dataset_servers.first.name)
+    end
+
+    desc "panic", "Destroy some instances or whatever?  Who cares."
+    def panic
+      check_dataset
+      check_servers
+
+      dataset_servers.each { |s| say_message_for(:stop, :success, s.name) }
+      dataset_servers.each(&:destroy)
+      say_waiting_until { !any_running? }
+      say_message_for(:terminate, :success)
+    end
+
+    desc "ssh", "I'm just gonna take a moment okay?"
+    def ssh
+      check_dataset
+      check_servers
+
+      exec("ssh -i #{config.private_key_path} root@#{dataset_servers.first.public_ip_address}")
+    end
+
+    desc "bootstrap", "You know those boots are like 90s style right"
+    def bootstrap
+      check_dataset
+      check_servers
+
+      remote.upload("#{script_path}/", "script/")
+      remote.system!("script/bootstrap.sh")
+      say_message_for(:bootstrap, :success, dataset_servers.first.name)
+    end
+
+    desc "chef", "Can you like make some spaghetti?  I'm so high."
+    def chef
+      check_dataset
+      check_servers
+
+      install_cookbooks if cheffile_exists?
+      remote_config.run_chef
+      say_message_for(:chef, :success, dataset_servers.first.name)
+    end
+
+    desc "snapshot", "OMGGGGGG this jon lenin shirt is so ammmmazingggg"
+    def snapshot(name)
+      check_dataset
+      check_servers
+      check_no_snapshot_named(name)
+
+      joyent.snapshots.create(dataset_servers.first.id, name)
+      say_message_for(:snapshot, :success, dataset_servers.first.name, name)
+    end
+
+    private
+
+    def cheffile_exists?
+      File.exists?(File.expand_path("../Cheffile", config_path))
+    end
+
+    def install_cookbooks
+      Dir.chdir(File.dirname(config_path)) do
+        Librarian::Chef::Cli.with_environment do
+          Librarian::Chef::Cli.new.install
+        end
+      end
+    end
+
+    def any_running?
+      dataset_servers.any? do |server|
+        begin
+          server.reload
+          server.state == "running"
+        rescue Excon::Errors::Gone
+          false
+        end
+      end
+    end
+
+    def check_dataset
+      if config.dataset.nil?
+        raise Thor::Error.new("requires a dataset the first time out")
+      end
+    end
+
+    def check_servers
+      if dataset_servers.empty?
+        raise Thor::Error.new("found zero servers with dataset #{config.dataset}")
+      end
+    end
+
+    def check_no_servers
+      unless dataset_servers.empty?
+        raise Thor::Error.new("cannot clobber an existing instance")
+      end
+    end
+
+    def check_no_snapshot_named(name)
+      if dataset_servers.first.snapshots.any? { |s| s.name == name }
+        raise Thor::Error.new("there is already a snapshot called #{name}")
+      end
+    end
+
+    def script_path
+      File.expand_path("../../../script", __FILE__)
+    end
+
+    def dataset_servers
+      joyent.servers.reload.select do |server|
+        server.dataset == config.dataset
+      end
+    end
+
+    def say_waiting_until
+      say_waiting
+      say_until(".", nil, false) do
+        yield.tap do |all_done|
+          unless all_done
+            say_boring if rand < 0.1
+            sleep 1
+          end
+        end
+      end
+    end
+
+    def remote_config
+      @remote_config ||= ManicBaker::RemoteConfig.new(config, remote)
+    end
+
+    def remote
+      @remote ||= Soloist::Remote.new(
+        "root",
+        dataset_servers.first.public_ip_address,
+        config.private_key_path
+      )
+    end
+
+    def joyent
+      @joyent ||= Fog::Compute.new(
+        provider: "Joyent",
+        joyent_url: config.joyent_uri
+      )
+    end
+
+    def config
+      @config ||= ManicBaker::Config.from_file(config_path)
+    end
+
+    def config_path
+      @config_path ||= Soloist::Spotlight.find!(".baker.yml")
+    end
+  end
+end

data/lib/manic_baker/config.rb

@@ -0,0 +1,21 @@
+require "soloist/royal_crown"
+
+module ManicBaker
+  class Config < Soloist::RoyalCrown
+    property :dataset
+    property :joyent_uri, :default => "https://us-east-1.api.joyentcloud.com"
+    property :flavor, :default => "Small 1GB"
+    property :ssh_key_name, :default => "id_rsa"
+    property :private_key_path, :default => File.expand_path("~/.ssh/id_rsa")
+
+    def public_key_path
+      "#{self.private_key_path}.pub"
+    end
+
+    private
+
+    def self.nilable_properties
+      (properties - [:path, :dataset]).map(&:to_s)
+    end
+  end
+end

data/lib/manic_baker/remote_config.rb

@@ -0,0 +1,57 @@
+require "soloist/config"
+require "soloist/remote"
+
+module ManicBaker
+  class RemoteConfig < Soloist::Config
+    attr_reader :remote
+
+    def initialize(royal_crown, remote)
+      @royal_crown = royal_crown
+      @remote = remote
+    end
+
+    def run_chef
+      remote.system!(conditional_sudo(%(/usr/bin/bash -lc "#{chef_solo}")))
+    end
+
+    def node_json_path
+      @node_json_path ||= File.expand_path("node.json", chef_config_path).tap do |path|
+        remote.system!(%(echo '#{JSON.dump(as_node_json)}' | #{conditional_sudo("tee #{path}")}))
+      end
+    end
+
+    def solo_rb_path
+      @solo_rb_path ||= File.expand_path("solo.rb", chef_config_path).tap do |path|
+        remote.system!(%(echo '#{as_solo_rb}' | #{conditional_sudo("tee #{path}")}))
+      end
+    end
+
+    def chef_cache_path
+      @chef_cache_path ||= "/var/chef/cache".tap do |cache_path|
+        remote.system!(conditional_sudo("/opt/local/bin/mkdir -m 777 -p #{cache_path}"))
+      end
+    end
+
+    def chef_config_path
+      @chef_config_path ||= "/etc/chef".tap do |path|
+        remote.system!(conditional_sudo("/opt/local/bin/mkdir -m 777 -p #{path}"))
+      end
+    end
+
+    def cookbook_paths
+      @cookbook_paths ||= ["/var/chef/cookbooks".tap do |remote_path|
+        remote.system!(conditional_sudo("/opt/local/bin/mkdir -m 777 -p #{remote_path}"))
+        super.each { |path| remote.upload("#{path}/", remote_path) }
+      end]
+    end
+
+    protected
+    def conditional_sudo(command)
+      root? ? command : "/usr/bin/pfexec -E #{command}"
+    end
+
+    def root?
+      remote.user == "root"
+    end
+  end
+end

data/lib/manic_baker/version.rb

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

data/lib/thor/shell/mean.rb

@@ -0,0 +1,34 @@
+class Thor
+  module Shell
+    module Mean
+      def messages
+        path = File.expand_path("../../../../config/locales/en.yml", __FILE__)
+        @messages ||= YAML.load_file(path)
+      end
+
+      def message_for(topic, state, *parameters)
+        messages[state.to_s][topic.to_s].sample % parameters
+      end
+
+      def say_message_for(topic, state, *parameters)
+        say_status(topic, message_for(topic, state, *parameters))
+      end
+
+      def say_until(*args)
+        say(*args) until yield
+        say
+      end
+
+      def say_waiting
+        status = set_color("waiting".rjust(12), :green, true)
+        say("#{status}  ", nil, false)
+      end
+
+      def say_boring
+        puts
+        say_status(nil, messages["boring"].sample)
+        say_waiting
+      end
+    end
+  end
+end

data/manic_baker.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'manic_baker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "manic_baker"
+  spec.version       = ManicBaker::VERSION
+  spec.authors       = ["Doc Ritezel"]
+  spec.email         = ["doc@minifast.co"]
+  spec.description   = %q{Makes Joyent less manic}
+  spec.summary       = %q{Stop calling the Ghostbusters just because you don't like my music, mom}
+  spec.homepage      = "https://github.com/minifast/manic_baker"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.executables   = `git ls-files -- bin`.split("\n").map { |f| File.basename(f) }
+  spec.test_files    = `git ls-files -- spec`.split("\n")
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "fog"
+  spec.add_dependency "soloist"
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-bundler"
+  spec.add_development_dependency "gem-release"
+end

data/script/bootstrap.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+pkgin list | grep ^ruby193-[0-9] ;
+if [ $? -gt 0 ]; then
+  pkgin -y install ruby193 ;
+fi ;
+
+pkgin list | grep ^gmake-[0-9] ;
+if [ $? -gt 0 ]; then
+  pkgin -y install gmake ;
+fi ;
+
+pkgin list | grep ^gcc47-[0-9] ;
+if [ $? -gt 0 ]; then
+  pkgin -y install gcc47 ;
+fi ;
+
+gem list | grep ^chef
+if [ $? -gt 0 ]; then
+  gem install chef --no-ri -no-rdoc ;
+fi
+
+test -h /opt/local/bin/chef-client ;
+if [ $? -gt 0 ]; then
+  ln -s /opt/local/lib/ruby/gems/1.9.3/gems/*/bin/chef-client /opt/local/bin/chef-client ;
+fi
+
+test -h /opt/local/bin/chef-solo ;
+if [ $? -gt 0 ]; then
+  ln -s /opt/local/lib/ruby/gems/1.9.3/gems/*/bin/chef-solo /opt/local/bin/chef-solo ;
+fi

data/script/ci.sh

@@ -0,0 +1 @@
+bundle exec rspec

data/spec/lib/manic_baker/cli_spec.rb

@@ -0,0 +1,255 @@
+require "spec_helper"
+
+describe ManicBaker::Cli do
+  let(:config) { ManicBaker::Config.new }
+  let(:config_hash) { config.to_hash }
+
+  let(:dataset) { "some-image-or-other" }
+  let(:server_dataset) { dataset }
+
+  let(:fake_server) { double(:server, dataset: server_dataset, name: "this server is so great") }
+  let(:fake_server_collection) { [fake_server] }
+  let(:fake_joyent) { double(:joyent, servers: fake_server_collection) }
+
+  subject(:cli) { ManicBaker::Cli.new }
+
+  before do
+    fake_server.stub(reload: fake_server)
+    fake_server_collection.stub(reload: fake_server_collection)
+    cli.stub(config: config, joyent: fake_joyent, say: nil, say_status: nil)
+  end
+
+  describe "#launch" do
+    let(:new_fake_server) { double(:server, dataset: dataset, state: "running", name: "some new server") }
+
+    before do
+      fake_server_collection.stub(:create) do
+        fake_server_collection << new_fake_server
+        new_fake_server
+      end
+    end
+
+    context "with a dataset" do
+      let(:config_hash) { config.to_hash.merge("dataset" => dataset) }
+
+      context "when no instances exist with the dataset" do
+        let(:server_dataset) { "i-am-another-data-set" }
+
+        it "creates a new instance on joyent" do
+          fake_server_collection.should_receive(:create).with(config_hash)
+          cli.launch(dataset)
+        end
+
+        it "writes the dataset to the config file" do
+          expect do
+            cli.launch(dataset)
+          end.to change { config.dataset }.from(nil).to(dataset)
+        end
+      end
+
+      context "when an instance exists with the dataset" do
+        it "raises an error" do
+          expect { cli.launch(dataset) }.to raise_error(Thor::Error)
+        end
+      end
+    end
+
+    context "without a dataset" do
+      context "when the config has a dataset" do
+        let(:fake_server_collection) { [] }
+        let(:dataset) { "fancy-dataset" }
+
+        before { config.dataset = dataset }
+
+        it "does not change the dataset in the config file" do
+          expect { cli.launch }.to_not change { config.dataset }
+        end
+      end
+
+      context "when the config does not have a dataset" do
+        it "raises an error" do
+          expect { cli.launch }.to raise_error(Thor::Error)
+        end
+      end
+    end
+  end
+
+  describe "#panic" do
+    before do
+      fake_server.stub(destroy: nil)
+    end
+
+    context "with a dataset in the config" do
+      before { config.dataset = dataset }
+
+      context "when there is a server with the dataset" do
+        before { fake_server.stub(state: "stopped") }
+
+        it "destroys the server" do
+          fake_server.should_receive(:destroy)
+          cli.panic
+        end
+
+        context "when reloading the server raises 410 Gone" do
+          it "does not raise an error" do
+            fake_server.stub(:reload).and_raise(Excon::Errors::Gone.new("no"))
+            expect { cli.panic }.to_not raise_error
+          end
+        end
+      end
+
+      context "when the server has a different dataset" do
+        let(:server_dataset) { "guess-who" }
+
+        it "does not destroy the server" do
+          expect { cli.panic }.to raise_error(Thor::Error)
+        end
+      end
+    end
+
+    context "with no dataset in the config" do
+      before { config.dataset = nil }
+
+      it "raises an exception" do
+        expect { cli.panic }.to raise_error(Thor::Error)
+      end
+    end
+  end
+
+  describe "#ssh" do
+    before do
+      fake_server.stub(public_ip_address: "some-host")
+      cli.stub(exec: nil)
+    end
+
+    context "with a dataset in the config" do
+      before { config.dataset = dataset }
+
+      context "when there is a server with the dataset" do
+        it "starts an ssh session to the host" do
+          cli.should_receive(:exec).with("ssh -i #{config.private_key_path} root@some-host")
+          cli.ssh
+        end
+      end
+
+      context "when the server has a different dataset" do
+        let(:server_dataset) { "guess-who" }
+
+        it "does not destroy the server" do
+          expect { cli.ssh }.to raise_error(Thor::Error)
+        end
+      end
+    end
+
+    context "with no dataset in the config" do
+      before { config.dataset = nil }
+
+      it "raises an exception" do
+        expect { cli.ssh }.to raise_error(Thor::Error)
+      end
+    end
+  end
+
+  describe "#bootstrap" do
+    let(:fake_remote) { double(:remote, system!: nil, upload: nil) }
+
+    before { cli.stub(remote: fake_remote) }
+
+    context "with a dataset in the config" do
+      let(:script_path) { File.expand_path("../../../../script", __FILE__) }
+
+      before { config.dataset = dataset }
+
+      context "when the server is in the same dataset" do
+        it "uploads the script directory" do
+          fake_remote.should_receive(:upload).with("#{script_path}/", "script/")
+          cli.bootstrap
+        end
+
+        it "runs the bootstrap script" do
+          fake_remote.should_receive(:system!).with("script/bootstrap.sh")
+          cli.bootstrap
+        end
+      end
+
+      context "when the server has a different dataset" do
+        let(:server_dataset) { "i-am-so-tired-of-guessing" }
+
+        it "does not destroy the server" do
+          expect { cli.bootstrap }.to raise_error(Thor::Error)
+        end
+      end
+    end
+
+    context "with no dataset in the config" do
+      before { config.dataset = nil }
+
+      it "raises an exception" do
+        expect { cli.bootstrap }.to raise_error(Thor::Error)
+      end
+    end
+  end
+
+  describe "#chef" do
+    let(:fake_remote_config) { double(:remote_config) }
+
+    before { cli.stub(remote_config: fake_remote_config, install_cookbooks: nil) }
+
+    context "with a dataset in the config" do
+      before { config.dataset = dataset }
+
+      context "when there is a server with the dataset" do
+        before { Soloist::Spotlight.stub(find!: ".") }
+
+        it "runs chef using the remote config" do
+          fake_remote_config.should_receive(:run_chef)
+          cli.chef
+        end
+      end
+
+      context "when the server has a different dataset" do
+        let(:server_dataset) { "wait, there's more than one of these?" }
+
+        it "does not destroy the server" do
+          expect { cli.chef }.to raise_error(Thor::Error)
+        end
+      end
+    end
+
+    context "with no dataset in the config" do
+      before { config.dataset = nil }
+
+      it "raises an exception" do
+        expect { cli.chef }.to raise_error(Thor::Error)
+      end
+    end
+  end
+
+  describe "#snapshot" do
+    context "with a dataset in the config" do
+      before { config.dataset = dataset }
+
+      context "when there is a server with the dataset" do
+        it "starts an ssh session to the host" do
+          cli.snapshot("teeth")
+        end
+      end
+
+      context "when the server has a different dataset" do
+        let(:server_dataset) { "wait, there's more than one of these?" }
+
+        it "does not destroy the server" do
+          expect { cli.snapshot("toes") }.to raise_error(Thor::Error)
+        end
+      end
+    end
+
+    context "with no dataset in the config" do
+      before { config.dataset = nil }
+
+      it "raises an exception" do
+        expect { cli.snapshot("omg braces?") }.to raise_error(Thor::Error)
+      end
+    end
+  end
+end

data/spec/lib/manic_baker/config_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe ManicBaker::Config do
+  let(:contents) { { "recipes" => ["broken_vim"] } }
+  let(:tempfile) do
+    Tempfile.new("manic-baker-config").tap do |file|
+      file.write(YAML.dump(contents))
+      file.close
+    end
+  end
+
+  let(:royal_crown) { ManicBaker::Config.from_file(tempfile.path) }
+
+  describe "defaults" do
+    its(:dataset) { should be_nil }
+    its(:flavor) { should == "Small 1GB" }
+    its(:joyent_uri) { should == "https://us-east-1.api.joyentcloud.com" }
+    its(:private_key_path) { should == File.expand_path("~/.ssh/id_rsa") }
+    its(:public_key_path) { should == File.expand_path("~/.ssh/id_rsa.pub") }
+  end
+
+  describe ".from_file" do
+    context "when the rc file is empty" do
+      let(:tempfile) do
+        Tempfile.new("manic-baker-config").tap do |file|
+          file.close
+        end
+      end
+
+      it "loads an empty file" do
+        expect { royal_crown }.not_to raise_error
+      end
+    end
+
+    it "loads from a yaml file" do
+      royal_crown.recipes.should =~ ["broken_vim"]
+    end
+
+    it "defaults nil fields to an empty primitive" do
+      royal_crown.node_attributes.should == {}
+    end
+
+    context "when the rc file has ERB tags" do
+      let(:tempfile) do
+        Tempfile.new("manic-baker-config").tap do |file|
+          file.write(<<-YAML
+          recipes:
+            - broken_vim
+          node_attributes:
+            evaluated: <%= "From ERB" %>
+          YAML
+          )
+          file.close
+        end
+      end
+
+      it "evaluates the ERB and parses the resulting YAML" do
+        royal_crown.node_attributes.should == {
+          "evaluated" => "From ERB"
+        }
+        royal_crown.recipes.should =~ ["broken_vim"]
+      end
+    end
+  end
+
+  describe "#save" do
+    it "writes the values to a file" do
+      royal_crown.recipes = ["hot_rats", "tissue_paper"]
+      royal_crown.save
+      royal_crown = ManicBaker::Config.from_file(tempfile.path)
+      royal_crown.recipes.should =~ ["hot_rats", "tissue_paper"]
+    end
+  end
+
+  describe "#to_yaml" do
+    it "skips the path attribute" do
+      royal_crown.to_yaml.keys.should_not include "path"
+    end
+
+    it "nils out fields that have not been set" do
+      royal_crown.to_yaml["node_attributes"].should be_nil
+    end
+  end
+end

data/spec/lib/manic_baker/remote_config_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe ManicBaker::RemoteConfig do
+  let(:contents) { {} }
+  let(:tempfile) do
+    Tempfile.new("manic-baker-config").tap do |file|
+      file.write(YAML.dump(contents))
+      file.close
+    end
+  end
+  let(:config) { ManicBaker::Config.new(:path => tempfile.path) }
+  let(:remote) { Soloist::Remote.new("user", "host", "key") }
+  let(:remote_config) { ManicBaker::RemoteConfig.new(config, remote) }
+
+  before { remote.stub(:backtick => "", :system => 0) }
+
+  def commands_for(method)
+    [].tap do |commands|
+      remote.stub(:system) { |c| commands << c; 0 }
+      remote.stub(:backtick) { |c| commands << c; "" }
+      remote_config.send(method)
+    end
+  end
+
+  describe "#chef_config_path" do
+    it "sets the path" do
+      remote_config.chef_config_path.should == "/etc/chef"
+    end
+
+    it "creates the path remotely" do
+      commands_for(:chef_config_path).tap do |commands|
+        commands.should have(1).command
+        commands.first.should =~ /mkdir .*? -p \/etc\/chef$/
+      end
+    end
+  end
+
+  describe "#chef_cache_path" do
+    it "sets the path" do
+      remote_config.chef_cache_path.should == "/var/chef/cache"
+    end
+
+    it "creates the path remotely" do
+      commands_for(:chef_cache_path).tap do |commands|
+        commands.should have(1).command
+        commands.first.should =~ /mkdir .*? -p \/var\/chef\/cache$/
+      end
+    end
+  end
+
+  describe "#cookbook_paths" do
+    it "sets the path" do
+      remote_config.cookbook_paths.should have(1).path
+      remote_config.cookbook_paths.should =~ ["/var/chef/cookbooks"]
+    end
+
+    it "creates the path remotely" do
+      commands_for(:cookbook_paths).tap do |commands|
+        commands.should have(1).command
+        commands.first.should =~ /mkdir .*? -p \/var\/chef\/cookbooks$/
+      end
+    end
+  end
+end

data/spec/lib/thor/shell/mean_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe Thor::Shell::Mean do
+  let(:contents) { { "failure" => { "binge_drinking" => ["your %s is over"] } } }
+
+  class MeanHarness
+    include Thor::Shell::Mean
+
+    def say(string, _ = nil, newline = true)
+      newline ? puts(string) : print(string)
+    end
+    def say_status(*args)
+      say(args)
+    end
+    def set_color(string, *args)
+      string
+    end
+  end
+
+  subject(:mean) { MeanHarness.new }
+
+  before { mean.stub(messages: contents) }
+
+  describe "attributes" do
+    context "when the messages path has been set" do
+      its(:messages) { should have_key("failure") }
+      its(:'messages.values.first') { should have_key("binge_drinking") }
+    end
+  end
+
+  describe "#message_for" do
+    let(:parameters) { ["life"] }
+    let(:topic) { :binge_drinking }
+    let(:state) { :failure }
+
+    context "when the topic exists" do
+      context "when the state exists" do
+        specify { mean.message_for(topic, state, *parameters).should == "your life is over" }
+      end
+
+      context "when the state does not exist" do
+        let(:state) { :success }
+
+        specify { expect { mean.message_for(topic, state, *parameters) }.to raise_error(NoMethodError) }
+      end
+    end
+
+    context "when the topic does not exist" do
+      let(:topic) { :empathy }
+
+      specify { expect { mean.message_for(topic, state, *parameters) }.to raise_error(NoMethodError) }
+    end
+
+    context "when there are not enough parameters" do
+      specify { expect { mean.message_for(topic, state) }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe "#say_message_for" do
+    let(:output) do
+      capture(:stdout) do
+        mean.say_message_for(:binge_drinking, :failure, "relationship")
+      end
+    end
+
+    specify { output.should include "binge_drinking" }
+    specify { output.should include "your relationship is over" }
+  end
+
+  describe "#say_until" do
+    context "with a state that is always true" do
+      it "does not pass arguments to say" do
+        mean.should_not_receive(:say).with(:anything)
+        mean.should_receive(:say).with(no_args)
+        mean.say_until(:anything) { true }
+      end
+    end
+
+    context "with a state that transitions from false to true" do
+      it "passes arguments to say" do
+        mean.should_receive(:say).once.with(:anything)
+        mean.should_receive(:say).with(no_args)
+        index = 0
+        mean.say_until(:anything) { (index += 1) == 2 }
+      end
+    end
+  end
+
+  describe "#say_waiting" do
+    let(:output) { capture(:stdout) { mean.say_waiting } }
+
+    specify { output.should include "waiting" }
+    specify { output.should_not include "\n" }
+  end
+
+  describe "#say_boring" do
+    let(:contents) { { "boring" => ["ugh"] } }
+    let(:output) { capture(:stdout) { mean.say_boring } }
+
+    specify { output.should include "ugh" }
+    specify { output.should include "waiting" }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$:<<File.expand_path("../../lib", __FILE__)
+
+require "manic_baker"
+
+Dir.glob(File.expand_path("../support/**/*.rb", __FILE__)) { |f| require f }
+
+RSpec.configure do |config|
+  config.include CaptureStreamHelpers
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/support/capture_stream_helpers.rb

@@ -0,0 +1,14 @@
+module CaptureStreamHelpers
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: manic_baker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Doc Ritezel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: soloist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Makes Joyent less manic
+email:
+- doc@minifast.co
+executables:
+- manic
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- bin/manic
+- config/locales/en.yml
+- lib/manic_baker.rb
+- lib/manic_baker/cli.rb
+- lib/manic_baker/config.rb
+- lib/manic_baker/remote_config.rb
+- lib/manic_baker/version.rb
+- lib/thor/shell/mean.rb
+- manic_baker.gemspec
+- script/bootstrap.sh
+- script/ci.sh
+- spec/lib/manic_baker/cli_spec.rb
+- spec/lib/manic_baker/config_spec.rb
+- spec/lib/manic_baker/remote_config_spec.rb
+- spec/lib/thor/shell/mean_spec.rb
+- spec/spec_helper.rb
+- spec/support/capture_stream_helpers.rb
+homepage: https://github.com/minifast/manic_baker
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Stop calling the Ghostbusters just because you don't like my music, mom
+test_files:
+- spec/lib/manic_baker/cli_spec.rb
+- spec/lib/manic_baker/config_spec.rb
+- spec/lib/manic_baker/remote_config_spec.rb
+- spec/lib/thor/shell/mean_spec.rb
+- spec/spec_helper.rb
+- spec/support/capture_stream_helpers.rb