minionizer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd7dc40fdbe374f013b0e9e807c3bc974215a951
+  data.tar.gz: ddcb859dd3f2d985341553cf923cc4de4422b19d
+SHA512:
+  metadata.gz: 2556cc919d6e3dc13fafd41406726bdd8bc640c5b27d75ca67614a4b14a06c9d465f08558e3943caa6daf0752e1a49d4044672996cfc6206db660336a922ed6f
+  data.tar.gz: b73ba6895d71e3b8d3aa9bd37dc3c01368bd160f71383cb09feb49cb7112738346620d283b5448dbcb4eb024184eee9bce9322c9c14ec0afa3f022f9edfb200d

data/.gitignore

@@ -0,0 +1,3 @@
+*.swp
+test/.vagrant
+

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    minionizer (0.0.1)
+      activesupport
+      net-ssh
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.0.4)
+      i18n (~> 0.6, >= 0.6.9)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.16)
+    fakefs (0.5.2)
+    i18n (0.6.9)
+    metaclass (0.0.4)
+    minitest (4.7.5)
+    mocha (1.0.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.9.2)
+    net-ssh (2.8.0)
+    thread_safe (0.3.1)
+      atomic (>= 1.1.7, < 2)
+    tzinfo (0.3.39)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakefs
+  minionizer!
+  mocha

data/README.md

@@ -0,0 +1,87 @@
+[![Code Climate](https://codeclimate.com/github/jsgarvin/minionizer.png)](https://codeclimate.com/github/jsgarvin/minionizer)
+
+# Minionizer
+
+Minionizer aims to be a light weight, yet powerful, server provisioning tool with minimum learning
+curve.
+
+Minionizer is still in alpha development and is not yet ready for anything resembling production use.
+
+# Overview
+
+Minionizer allows you keep all of your provisioning "recipies" for a set of servers, along with any
+data those recipies may need (such as config files), in a single git repository.
+
+Minionizer uses ssh to connect to machines and run commands. There are no "agents" or other software
+to install on servers before minionizer can take over.
+
+Managed machines (minions) are assigned roles (web, db, production, staging, etc) and can be
+(re)provisioned all at once by any role, or individually by server address.
+
+Sensitive data, such as passwords, WILL BE gpg encrypted and only the encrypted copies will be checked
+into the repository. If you change any of these files, Minionizer will detect the change and prompt
+you to re-encrypt them and commit the newly encrypted versions.
+
+A core set of commands WILL BE provided, such as uploading files to the server, installing apt
+packages, etc. You can use these core commands to build more complex recipies, or use any of many
+minionizer plugins that WILL BE available, such as posgresql installationi/upgrade, ruby
+installation/upgrade, etc. 
+
+# Installation
+
+    gem install minionizer
+
+# Usage
+
+## Setup a new provisioning project in the current folder.
+Note: This step doesn't actually work yet.
+
+    minionize --init subfolder_name
+
+Creates `subfolder_name` and initializes it with some initial folders and files to get you started.
+
+## Modify config/minions.yml
+
+The minions.yml file is where you define what servers this project will manage and what roles
+each server will play.
+
+You will probably want assign each server multiple roles, such as `['production', 'db']`.
+
+## Create role instructions
+
+A sample role file WILL BE provided in the ./roles folder to get you started. Each role file defines
+what servers assigned that role should do on each (re)provisioning.
+
+It is not necessary to create a role file for every role that you added to your config/minions.yml
+file. You will likely have some roles, such as "production", that are mearly a means of grouping
+several servers together and won't have a corresponding role file.  You will need at least one role,
+though, such as "db" or "webserver", that will have a corresponding role file.
+
+## Provision Servers
+
+To provision all of the servers that are assigned a particular role, run...
+
+    minionize role_name
+
+This will loop through each server that is assigned `role_name` and run each role file for each role
+that that server is assigned.  For instance, if a server is assigned the roles 'production' and 'db',
+and you run `minionize production`, then when minionizer reaches this machine, it will run the 'db'
+role file (assuming it exists in the ./roles folder).
+
+or
+
+    minionize my.server.address.com
+
+This will loop through each role that is assigned to just that server, and any corresponding role
+files will be run.
+
+# Contribute
+
+To contribute to Minionizer development you will need to install [vagrant](http://www.vagrantup.com/)
+and [VirtualBox](https://www.virtualbox.org/) in order to be able to run acceptance tests.
+
+Once installed from within your own clone of the Minionizer repo, run `rake test:vm:start` to
+initialize the acceptance test virtual machine. The first time you do this it may take a long time to
+download install the initial box.
+
+To shut down the vm, run `rake test:vm:stop`.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rake/testtask'
+require 'pty'
+
+require_relative 'lib/minionizer'
+
+task default: :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+namespace :test do
+  namespace :vm do
+    task :start do
+      relay_output(vagrant_command(:up))
+      unless snapshot_plugin_installed?
+        relay_output(vagrant_command('plugin install vagrant-vbox-snapshot'))
+        relay_output(vagrant_command('snapshot take blank-test-slate'))
+      end
+    end
+    task :stop do
+      relay_output(vagrant_command(:halt))
+    end
+  end
+end
+
+def vagrant_command(command)
+  "cd #{vagrant_path}; vagrant #{command}"
+end
+
+def snapshot_plugin_installed?
+  vagrant_plugins['vagrant-vbox-snapshot'] &&
+    Gem::Version.new(vagrant_plugins['vagrant-vbox-snapshot']) >= Gem::Version.new('0.0.4')
+end
+
+def vagrant_plugins
+  Hash.new.tap do |hash|
+    `cd #{vagrant_path}; vagrant plugin list`.split("\n").each do |plugin_string|
+      if plugin_string.match(/([^\s]+)\s\(([0-9\.]+)/)
+        hash[$1] = $2
+      end
+    end
+  end
+end
+
+def vagrant_path
+  File.expand_path('../test', __FILE__)
+end
+
+def relay_output(command)
+  begin
+    PTY.spawn(command) do |stdin, stdout, pid|
+      begin
+        stdin.each {|line| print line }
+      rescue Errno::EIO
+      end
+    end
+  rescue PTY::ChildExited
+  end
+end

data/bin/minionize

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require_relative '../lib/minionizer'
+Minionizer::Minionization.new(ARGV, Minionizer::Configuration.instance).call

data/lib/core/file_injection.rb

@@ -0,0 +1,21 @@
+module Minionizer
+  class FileInjection
+    attr_reader :session
+
+    def initialize(session)
+      @session = session
+    end
+
+    def inject(source, target)
+      session.exec("echo '#{contents_from(source)}' > #{target}")
+    end
+
+    #######
+    private
+    #######
+
+    def contents_from(source)
+      File.open(source).read.strip
+    end
+  end
+end

data/lib/minionizer/configuration.rb

@@ -0,0 +1,10 @@
+module Minionizer
+  class Configuration
+    include Singleton
+
+    def minions
+      @minions ||= YAML::load_file('./config/minions.yml')
+    end
+  end
+end
+

data/lib/minionizer/minion.rb

@@ -0,0 +1,34 @@
+module Minionizer
+  class Minion
+    attr_reader :config, :fqdn, :session_constructor
+
+    def initialize(fqdn, config, session_constructor = Session)
+      @fqdn = fqdn
+      @config = config
+      @session_constructor = session_constructor
+    end
+
+    def session
+      @session ||= session_constructor.new(fqdn, ssh_credentials)
+    end
+
+    def roles
+      my_config['roles']
+    end
+
+    #######
+    private
+    #######
+
+    def ssh_credentials
+      {
+        'username' => my_config['ssh']['username'],
+        'password' => my_config['ssh']['password']
+      }
+    end
+
+    def my_config
+      config.minions[fqdn]
+    end
+  end
+end

data/lib/minionizer/minionization.rb

@@ -0,0 +1,60 @@
+module Minionizer
+  class Minionization
+    attr_reader :arguments, :config, :minion_constructor
+
+    def initialize(arguments, config, minion_constructor = Minion)
+      @arguments = arguments
+      @config = config
+      @minion_constructor = minion_constructor
+    end
+
+    def call
+      minions.each do |minion|
+        minion.roles.each { |name| execute_role(minion.session, name) }
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def minions
+      if first_argument_is_a_minion?
+        [construct_minion(first_argument)]
+      else
+        minions_for_role(first_argument)
+      end
+    end
+
+    def execute_role(session, name)
+      require role_path(name)
+      name.classify.constantize.new(session).call
+    end
+
+    def first_argument_is_a_minion?
+      config.minions.include?(first_argument)
+    end
+
+    def minions_for_role(role_name)
+      minion_names_for_role(role_name).map {|name| construct_minion(name) }
+    end
+
+    def construct_minion(name)
+      minion_constructor.new(name, config)
+    end
+
+    def role_path(name)
+      File.expand_path("./roles/#{name}.rb")
+    end
+
+    def minion_names_for_role(role_name)
+      config.minions.keys.select do |minion|
+        config.minions[minion]['roles'].include?(role_name)
+      end
+    end
+
+    def first_argument
+      @first_argument ||= arguments.pop
+    end
+  end
+end

data/lib/minionizer/role_template.rb

@@ -0,0 +1,13 @@
+module Minionizer
+  class RoleTemplate
+    attr_reader :session
+
+    def initialize(session)
+      @session = session
+    end
+
+    def call
+      raise StandardError.new('call method must be defined by inheriting role.')
+    end
+  end
+end

data/lib/minionizer/session.rb

@@ -0,0 +1,39 @@
+module Minionizer
+  class Session
+    attr_reader :fqdn, :username, :password, :connector
+
+    def initialize(fqdn, credentials, connector = Net::SSH)
+      @fqdn = fqdn
+      @username = credentials['username']
+      @password = credentials['password']
+      @connector = connector
+    end
+
+    def exec(arg)
+      if arg.is_a?(Array)
+        arg.map { |command| exec_single_command(command) }
+      else
+        exec_single_command(arg)
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def exec_single_command(command)
+      connection.exec(command) do |channel, stream, output|
+        if stream == :stdout
+          return output.strip
+        else
+          raise StandardError.new(output)
+        end
+      end
+      connection.loop
+    end
+
+    def connection
+      @connection ||= connector.start(fqdn, username, password: password)
+    end
+  end
+end

data/lib/minionizer/version.rb

@@ -0,0 +1,3 @@
+module Minionizer
+  VERSION = '0.0.1'
+end

data/lib/minionizer.rb

@@ -0,0 +1,6 @@
+require 'active_support/inflector'
+require 'net/ssh'
+require 'singleton'
+require 'yaml'
+
+Dir[File.dirname(__FILE__) + '/**/*.rb'].each { |file| require file }

data/minionizer.gemspec

@@ -0,0 +1,23 @@
+require_relative 'lib/minionizer/version'
+
+Gem::Specification.new do |s|
+  s.name = "minionizer"
+  s.version = Minionizer::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Jonathan S. Garvin"]
+  s.email = ["jon@5valleys.com"]
+  s.homepage = "https://github.com/jsgarvin/minionizer"
+  s.summary = %q{Simple server provisioning and management.}
+  s.description = %q{Minionizer aims to be a light weight server provisioning tool without bloat or steep learning curves.}
+
+  s.add_dependency('activesupport')
+  s.add_dependency('net-ssh')
+
+  s.add_development_dependency('fakefs')
+  s.add_development_dependency('mocha')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/Vagrantfile

@@ -0,0 +1,125 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  config.vm.define 'minion' do |minion|
+    minion.vm.box = 'precise32'
+    minion.vm.box_url = "http://files.vagrantup.com/precise32.box"
+    minion.vm.network "private_network", ip: "192.168.49.181"
+  end
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  # config.vm.box = "precise32"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  # config.vm.box_url = "http://domain.com/path/to/above.box"
+  # config.vm.box_url = "http://files.vagrantup.com/precise32.box"
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  # config.vm.network "forwarded_port", guest: 80, host: 8080
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  # config.vm.network "private_network", ip: "192.168.33.10"
+
+  # Create a public network, which generally matched to bridged network.
+  # Bridged networks make the machine appear as another physical device on
+  # your network.
+  # config.vm.network "public_network"
+
+  # If true, then any SSH connections made will enable agent forwarding.
+  # Default value: false
+  # config.ssh.forward_agent = true
+
+  # Share an additional folder to the guest VM. The first argument is
+  # the path on the host to the actual folder. The second argument is
+  # the path on the guest to mount the folder. And the optional third
+  # argument is a set of non-required options.
+  # config.vm.synced_folder "../data", "/vagrant_data"
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+  # Example for VirtualBox:
+  #
+  # config.vm.provider "virtualbox" do |vb|
+  #   # Don't boot with headless mode
+  #   vb.gui = true
+  #
+  #   # Use VBoxManage to customize the VM. For example to change memory:
+  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
+  # end
+  #
+  # View the documentation for the provider you're using for more
+  # information on available options.
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file base.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision "puppet" do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "site.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
+  # some recipes and/or roles.
+  #
+  # config.vm.provision "chef_solo" do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision "chef_client" do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # If you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/test/integration/acceptance_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+module Minionizer
+  class VictoryLap < StandardError; end
+  class MinionTestFailure < StandardError; end
+  class AcceptanceTest < MiniTest::Unit::TestCase
+
+    describe 'acceptance testing' do
+      let(:fqdn) { '192.168.49.181' }
+      let (:username) { 'vagrant' }
+      let (:password) { 'vagrant' }
+      let(:credentials) {{ 'username' => username, 'password' => password }}
+      let(:session) { Session.new(fqdn, credentials) }
+      let(:minionization) { Minionization.new([fqdn], Configuration.instance) }
+      let(:minions) {{ fqdn => { 'ssh' => credentials, 'roles' => ['minion_test'] } }}
+
+      before do
+        skip unless minion_available?
+        roll_back_to_blank_snapshot
+        Configuration.instance.instance_variable_set(:@minions, nil)
+        write_file('config/minions.yml', minions.to_yaml)
+        write_file('roles/minion_test.rb', TEST_ROLE)
+        write_file(INJECTION_SOURCE, 'FooBar')
+      end
+
+      describe 'setting up a server' do
+        it 'exercises from start to finish' do
+          begin
+            without_fakefs do
+              refute(File.exists?(synced_path_to_injected_file))
+            end
+            assert_raises(VictoryLap) do
+              minionization.call
+            end
+            without_fakefs do
+              assert(File.exists?(synced_path_to_injected_file))
+            end
+          ensure
+            without_fakefs do
+              File.delete(synced_path_to_injected_file)
+            end
+          end
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def without_fakefs
+        FakeFS.deactivate!
+        yield
+      ensure
+        FakeFS.activate!
+      end
+
+      def synced_path_to_injected_file
+        @synced_path_to_injected_file ||= File.expand_path("../../#{INJECTION_SOURCE}", __FILE__)
+      end
+    end
+  end
+end
+
+INJECTION_SOURCE = 'foobar.txt'
+INJECTION_TARGET = "/vagrant/#{INJECTION_SOURCE}"
+TEST_ROLE = <<-endofstring
+  class MinionTest < Minionizer::RoleTemplate
+
+    def call
+      if hostname == 'precise32'
+        Minionizer::FileInjection.new(session).inject('#{INJECTION_SOURCE}','#{INJECTION_TARGET}')
+        raise Minionizer::VictoryLap.new('Shazam!')
+      else
+        raise Minionizer::MinionTestFailure.new("Whawhawhaaaa... \#{hostname}")
+      end
+    end
+
+    def hostname
+      @hostname ||= session.exec(:hostname)
+    end
+  end
+endofstring

data/test/test_helper.rb

@@ -0,0 +1,101 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'fakefs/safe'
+require 'socket'
+require 'timeout'
+
+require_relative '../lib/minionizer'
+
+module Minionizer
+  class MiniTest::Unit::TestCase
+
+    def before_setup
+      super
+      initialize_fakefs
+    end
+
+    def after_teardown
+      super
+      FakeFS.deactivate!
+    end
+
+    #######
+    private
+    #######
+
+    def initialize_fakefs
+      FakeFS.activate!
+      FakeFS::FileSystem.clear
+      Kernel.class_eval do
+        alias_method :require, :fake_require
+      end
+    end
+
+    def minion_available?
+      Timeout.timeout(1) do
+        @@minion_available ||= TCPSocket.new('192.168.49.181', 22)
+      end
+    rescue Errno::ECONNREFUSED, Timeout::Error
+      return false
+    end
+
+    def initialize_minion
+      @@previously_initialized ||= `cd #{File.dirname(__FILE__)}; vagrant up`
+    end
+
+    def roll_back_to_blank_snapshot
+      FakeFS.deactivate!
+      `cd #{File.dirname(__FILE__)}; vagrant snapshot go blank-test-slate`
+      FakeFS.activate!
+    end
+
+    def write_role_file(name)
+      write_file("roles/#{name}.rb")
+    end
+
+    def write_file(path, contents = '')
+      FileUtils.mkdir_p File.dirname(path)
+      File.open("./#{path}", 'w') { |file| file.write(contents) }
+    end
+
+    def get_dynamic_class(name)
+      Object.const_get(name.classify)
+    rescue NameError
+      Object.const_set(name.classify, Class.new)
+    end
+
+  end
+end
+
+module Kernel
+
+  def fake_require(path)
+    File.open(path, "r") {|f| Object.class_eval f.read, path, 1 }
+  end
+
+end
+
+module MiniTest
+  class NamedMock < Mock
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      super()
+    end
+
+    # Because you ought to be able to
+    # test two effing mocks for equality.
+    def ==(x)
+      object_id == x.object_id
+    end
+
+    def method_missing(sym, *args, &block)
+      super(sym, *args, &block)
+    rescue NoMethodError, MockExpectationError, ArgumentError => error
+      raise(error.class, "#{error.message} (mock:#{name}) ")
+    end
+  end
+end
+
+require 'mocha/setup'

data/test/unit/lib/core/file_injection_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Minionizer
+  class FileInjectionTest < MiniTest::Unit::TestCase
+
+    describe FileInjection do
+      let(:session) { 'MockSession' }
+      let(:injection) { FileInjection.new(session) }
+
+      it 'instantiates' do
+        assert_kind_of(FileInjection, injection)
+      end
+
+      describe '#call' do
+        let(:source_contents) { 'Source Contents' }
+        let(:source) { 'data/source_file.txt'}
+        let(:target) { '/var/target_file.txt'}
+
+        before do
+          write_file(source, source_contents)
+          session.expects(:exec).with(%Q{echo '#{source_contents}' > #{target}})
+        end
+
+        it 'sends a command to session' do
+          injection.inject(source, target)
+        end
+      end
+
+    end
+  end
+end
+
+

data/test/unit/lib/minionizer/configuration_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Minionizer
+  class ConfigurationTest < MiniTest::Unit::TestCase
+
+    describe Configuration do
+      let(:config) { Configuration.instance }
+      let(:minions) {{ 'foo.bar.com' => { :ssh => { :username => 'foo', :password => 'bar' } } }}
+
+      before do
+        write_file('config/minions.yml', minions.to_yaml)
+      end
+
+      it 'instantiates a configuration' do
+        assert_kind_of(Configuration, config)
+      end
+
+      describe 'minions' do
+
+        it 'loads the minions' do
+          assert_kind_of(Hash, config.minions)
+          assert_includes(config.minions.keys, 'foo.bar.com')
+        end
+      end
+
+    end
+  end
+end

data/test/unit/lib/minionizer/minion_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Minionizer
+  class MinionTest < MiniTest::Unit::TestCase
+    describe Minion do
+      let(:username) { 'foo' }
+      let(:password) { 'bar' }
+      let(:credentials) {{ 'username' => username, 'password' => password }}
+      let(:config) { Configuration.instance }
+      let(:fqdn) { 'foo.bar.com' }
+      let(:session_constructor) { Struct.new(:fqdn, :credentials) }
+      let(:minion) { Minion.new(fqdn, config, session_constructor) }
+      let(:roles) { %w(foo bar) }
+      let (:minion_config) {{ fqdn => { 'roles' => roles , 'ssh' => credentials } }}
+
+      before do
+        config.stubs(:minions).returns(minion_config)
+      end
+
+      it 'instantiates' do
+        assert_kind_of(Minion, minion)
+      end
+
+      describe '#session' do
+        let(:session) { MiniTest::NamedMock.new('session') }
+
+        it 'creates a session' do
+          session_constructor.expects(:new).with(fqdn, credentials).returns(session)
+          minion.session
+        end
+      end
+
+      describe '#roles' do
+
+        it 'returns a list of roles' do
+          assert_equal(2,minion.roles.count)
+          roles.each { |role| assert_includes(minion.roles, role) }
+        end
+      end
+    end
+  end
+end
+
+

data/test/unit/lib/minionizer/minionization_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+module Minionizer
+  class MinionizationTest < MiniTest::Unit::TestCase
+
+    describe Minionization do
+      let(:fqdn) { 'foo.bar.com' }
+      let(:config) { Configuration.instance }
+      let(:role_name) { 'web_server' }
+      let(:role_class) { get_dynamic_class(role_name) }
+      let(:minion) { MiniTest::NamedMock.new('minion') }
+      let(:minionization) { Minionization.new(arguments, config, minion_constructor) }
+      let(:minion_roles) {{ fqdn => { 'roles' => [role_name] }}}
+      let(:minion_constructor) { Struct.new(:fqdn, :config) }
+      let(:session) { MiniTest::NamedMock.new('session') }
+      let(:role) { MiniTest::NamedMock.new('role') }
+
+      before do
+        config.stubs(:minions).returns(minion_roles)
+        minion.expect(:roles, [role_name])
+        minion_constructor.expects(:new).with(fqdn, config).returns(minion)
+        role_class.expects(:new).with(session).returns(role)
+        role.expect(:call, true)
+        minionization.expects(:require).with("/roles/#{role_name}.rb")
+        minion.expect(:session, session)
+      end
+
+      describe 'calling with a valid minion name' do
+        let(:arguments) { [fqdn] }
+
+        it 'executes a role' do
+          minionization.call
+        end
+      end
+
+      describe 'calling with a valid role' do
+        let(:arguments) { [role_name] }
+
+        it 'executes the role once for each minion' do
+          minionization.call
+        end
+      end
+    end
+
+  end
+end

data/test/unit/lib/minionizer/role_template_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+module Minionizer
+  class RoleTemplateTest < MiniTest::Unit::TestCase
+
+    describe RoleTemplate do
+      let(:session) { 'MockSession' }
+      let(:template) { RoleTemplate.new(session) }
+
+      it 'initilizes' do
+        assert_kind_of(RoleTemplate, template)
+      end
+
+      describe '#call' do
+        it 'raises' do
+          assert_raises(StandardError) { template.call }
+        end
+      end
+    end
+
+  end
+end
+

data/test/unit/lib/minionizer/session_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Minionizer
+  class SessionTest < MiniTest::Unit::TestCase
+
+    describe Session do
+      let(:fqdn) { 'foo.bar.com' }
+      let(:username) { 'foo' }
+      let(:password) { 'bar' }
+      let(:credentials) {{ 'username' => username, 'password' => password }}
+      let(:connector) { MiniTest::NamedMock.new(:connector) }
+      let(:channel) { MiniTest::NamedMock.new(:channel) }
+      let(:connection) { 'MockConnection' }
+      let(:session) { Session.new(fqdn, credentials, connector) }
+      let(:start_args) { [fqdn, username, { password: password }]}
+
+      it 'instantiates' do
+        assert_kind_of(Session, session)
+      end
+
+      describe 'running commands' do
+        let(:command) { 'foobar' }
+
+        before do
+          connector.expect(:start, connection, start_args)
+        end
+
+        describe 'when a single command is passed' do
+
+          before do
+            connection.expects(:exec).with(command).returns("#{command} pong")
+            connection.expects(:loop).returns('fixme')
+          end
+
+          it 'returns a single result' do
+            assert_kind_of(String, session.exec(command))
+          end
+        end
+
+        describe 'when multiple commands are passed' do
+          let(:commands) { %w(foo bar) }
+
+          before do
+            commands.each do |command|
+              connection.expects(:exec).with(command).returns("#{command} pong")
+            end
+            connection.expects(:loop).twice.returns('fixme')
+          end
+
+          it 'returns multiple results' do
+            assert_kind_of(Array, session.exec(commands))
+          end
+        end
+
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: minionizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jonathan S. Garvin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: net-ssh
+  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: fakefs
+  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: mocha
+  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: Minionizer aims to be a light weight server provisioning tool without
+  bloat or steep learning curves.
+email:
+- jon@5valleys.com
+executables:
+- minionize
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/minionize
+- lib/core/file_injection.rb
+- lib/minionizer.rb
+- lib/minionizer/configuration.rb
+- lib/minionizer/minion.rb
+- lib/minionizer/minionization.rb
+- lib/minionizer/role_template.rb
+- lib/minionizer/session.rb
+- lib/minionizer/version.rb
+- minionizer.gemspec
+- test/Vagrantfile
+- test/integration/acceptance_test.rb
+- test/test_helper.rb
+- test/unit/lib/core/file_injection_test.rb
+- test/unit/lib/minionizer/configuration_test.rb
+- test/unit/lib/minionizer/minion_test.rb
+- test/unit/lib/minionizer/minionization_test.rb
+- test/unit/lib/minionizer/role_template_test.rb
+- test/unit/lib/minionizer/session_test.rb
+homepage: https://github.com/jsgarvin/minionizer
+licenses: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Simple server provisioning and management.
+test_files:
+- test/Vagrantfile
+- test/integration/acceptance_test.rb
+- test/test_helper.rb
+- test/unit/lib/core/file_injection_test.rb
+- test/unit/lib/minionizer/configuration_test.rb
+- test/unit/lib/minionizer/minion_test.rb
+- test/unit/lib/minionizer/minionization_test.rb
+- test/unit/lib/minionizer/role_template_test.rb
+- test/unit/lib/minionizer/session_test.rb