gonzo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c6de463660b7b19173f1c55cc959da789352175e
+  data.tar.gz: 5467643687ac220822d5401813c2871e669afe91
+SHA512:
+  metadata.gz: b525b04275760a01f3ffdfbe2fa76a6a72beb05f5badb482e3ac43cc1dee28f9ac55e7878ab923ddcc2dfb0dd092f284bd18e38758f9b4dfe5693f700a5e7979
+  data.tar.gz: d6de87214e480a3f41edb25b145d4591bb2a9c95e0adf9176e32cf3d83467e264e8c59e7e155f972eb10f37fd250852c4f3626249488d0095c75883a58e634b8

data/README.md

@@ -0,0 +1,102 @@
+[![Build Status](https://travis-ci.org/danzilio/gonzo.svg?branch=master)](https://travis-ci.org/danzilio/gonzo) [![Gem Version](https://badge.fury.io/rb/gonzo.svg)](http://badge.fury.io/rb/gonzo)
+
+![Gonzo](http://a.dilcdn.com/bl/wp-content/uploads/sites/2/2013/11/gonzo-and-camilla-the-chicken2.jpg)
+
+Gonzo was inspired by [Beaker](https://github.com/puppetlabs/beaker), but is meant to be a little stupider. I set out to write Gonzo because I just wanted a way to spin up a VM or group of VMs programmatically and run ServerSpec tests on them. I wasn't interested in using the Beaker helpers or matchers. I just wanted something simple and agnostic. This is the hack that ensued.
+
+## Installation
+
+Install the Gem with the `gem` command:
+
+```
+gem install gonzo
+```
+
+Or add it to your `Gemfile`:
+
+```ruby
+source 'https://rubygems.org'
+
+gem 'gonzo'
+```
+
+## Usage
+
+At the root of your project, you'll need to create a `.gonzo.yml` file. This is where you'll configure VMs for Gonzo. You'll need to configure a supported provider. As of right now, the only supported provider is `vagrant`. The top-level key will be the name of the provider. Here's an example `.gonzo.yml` that contains a single VM:
+
+```yaml
+---
+  vagrant:
+    box: 'puppetlabs/centos-7.0-64-puppet'
+    env:
+      PUPPET_VERSION: '4.1.0'
+    commands:
+      - 'sudo yum -y install git ruby-devel libxml2-devel'
+      - 'sudo gem install bundler'
+      - 'rm Gemfile.lock'
+      - 'bundle install --path vendor'
+      - 'bundle exec rake spec'
+```
+
+You can configure multiple boxes to run serially by giving them a name:
+
+```yaml
+---
+  vagrant:
+    spec_tests:
+      box: 'puppetlabs/centos-7.0-64-puppet'
+      env:
+        PUPPET_VERSION: '4.1.0'
+      commands:
+        - 'sudo yum -y install git ruby-devel libxml2-devel'
+        - 'sudo gem install bundler'
+        - 'bundle install --path vendor'
+        - 'bundle exec rake spec'
+    acceptance_tests:
+      box: 'puppetlabs/centos-7.0-64-puppet'
+      env:
+        PUPPET_VERSION: '4.1.0'
+      commands:
+        - 'sudo yum -y install git ruby-devel libxml2-devel'
+        - 'sudo gem install bundler'
+        - 'bundle install --path vendor'
+        - 'bundle exec rake spec_prep'
+        - 'bundle exec puppet apply examples/init.pp --modulepath spec/fixtures/modules'
+        - 'bundle exec rake acceptance'
+```
+
+Once you've configured a `.gonzo.yml` file, you'll need to include the Rake tasks in your `Rakefile` by adding this line:
+
+```ruby
+require 'gonzo/rake_tasks'
+```
+
+This will make the `gonzo` rake task available to you. You can run Gonzo by running `bundle exec rake gonzo`. This will start all of the VMs serially. If one VM fails, by default Gonzo will continue on to the next VM in the list. You can configure this in `.gonzo.yml` by setting `stop_on_failure` to `true` in the `gonzo` section of `.gonzo.yml`. For example:
+
+```yaml
+---
+  gonzo:
+    stop_on_failure: true
+```
+
+Gonzo will aggregate the exit statuses from all VMs and exit 1 if any of them failed, or 0 if they all succeeded.
+
+### Commands
+
+Commands will be run sequentially inside the directory where your `.gonzo.yml` file is. The `vagrant` provider copies the directory to `/tmp/gonzo` instead of running in `/vagrant` to avoid changing the project in flight. If you want to retrieve test results or generated binaries, simply add a command to copy them into `/vagrant` at the end of your run:
+
+```yaml
+---
+  vagrant:
+    box: 'puppetlabs/centos-7.0-64-puppet'
+    env:
+      PUPPET_VERSION: '4.1.0'
+    commands:
+      - 'puppet module install puppetlabs-strings'
+      - 'puppet strings'
+      - 'cp -r doc /vagrant'
+```
+
+### Environment Variables
+
+The `env` key allows you to pass environment variables to your commands. The key must be the variable name, and the value the value you wish to assign to that variable.

data/bin/gonzo

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'gonzo'
+
+project = ARGV.last || '.'
+
+Gonzo::Runner.new(Gonzo.config('.')).run

data/lib/gonzo.rb

@@ -0,0 +1,26 @@
+require 'gonzo/runner'
+
+module Gonzo
+  def self.config(path = '.')
+    return @config if @config
+    project = File.expand_path(path)
+    config_file = File.join(project, '.gonzo.yml')
+    fail "No .gonzo.yml found in #{project}!" unless File.exist?(config_file)
+    data = YAML.load_file(config_file)
+    data['gonzo'] = global_defaults.merge data['gonzo'] || {}
+    data['gonzo']['project'] = project
+    data['gonzo']['statedir'] = "#{project}/.gonzo"
+    @config = data
+  end
+
+  def self.reload!
+    @config = nil
+  end
+
+  def self.global_defaults
+    {
+      'stop_on_failure' => false,
+      'cleanup' => true
+    }
+  end
+end

data/lib/gonzo/providers.rb

@@ -0,0 +1 @@
+require 'gonzo/providers/vagrant'

data/lib/gonzo/providers/vagrant.rb

@@ -0,0 +1,116 @@
+require 'fileutils'
+
+module Gonzo
+  module Providers
+    class Vagrant
+      attr_reader :config, :providerdir, :global
+
+      def initialize(config, global)
+        @global = global
+        @providerdir = "#{global['statedir']}/provider/vagrant"
+
+        if config.keys.include?('box')
+          @config = { 'default' => config }
+        else
+          @config = config
+        end
+      end
+
+      def cleanup
+        FileUtils.rm_rf File.join(global['project'], '.vagrant')
+        FileUtils.rm_rf 'Vagrantfile'
+      end
+
+      def shellscript(commands, env = nil)
+        script = []
+
+        script << '#!/bin/bash'
+        script << 'set -e'
+        script << 'set -x'
+        script << 'cp -r /vagrant /tmp/gonzo'
+        script << 'cd /tmp/gonzo'
+
+        if env
+          env.each do |k,v|
+            script << "export #{k}=\"#{v}\""
+          end
+        end
+
+        commands.each do |command|
+          script << command
+        end
+
+        script.join("\n")
+      end
+
+      def vagrantfile
+        vf = []
+
+        vf << 'VAGRANTFILE_API_VERSION = "2"'
+        vf << 'Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|'
+
+        config.each do |name,conf|
+          vf << "  config.vm.define :#{name} do |#{name}|"
+          vf << "    #{name}.vm.box = '#{conf['box']}'"
+          vf << "    #{name}.vm.box_url = '#{conf['box_url']}'" if conf['box_url']
+          vf << '  end'
+        end
+
+        vf << 'end'
+
+        vf.join("\n")
+      end
+
+      def up(box)
+        File.open('Vagrantfile', 'w') do |f|
+          f << vagrantfile
+        end
+        system "vagrant up #{box}"
+      end
+
+      def relative_providerdir
+        (providerdir.split('/') - global['project'].split('/')).join('/')
+      end
+
+      def provision(box, box_config)
+        FileUtils.mkdir_p(providerdir) unless File.directory?(providerdir)
+        local_script = "#{providerdir}/#{box}.sh"
+        relative_script = "#{relative_providerdir}/#{box}.sh"
+        if box_config['commands']
+          File.open(local_script, 'w') do |f|
+            f << shellscript(box_config['commands'], box_config['env'])
+          end
+          FileUtils.chmod('+x', local_script)
+          system "vagrant ssh #{box} -c /vagrant/#{relative_script}"
+        else
+          fail "No provisioner commands given for #{box}!"
+        end
+      end
+
+      def down(box)
+        system "vagrant destroy -f #{box}"
+      end
+
+      def run
+        exit_codes = []
+        config.each do |box, box_config|
+          up(box)
+
+          begin
+            exit_codes << provision(box, box_config)
+          rescue Exception => e           # We want to catch all exceptions here so we make sure we don't leave a VM hanging
+            puts "Exception caught! Cleaning up."
+            down(box)
+            puts e
+            return false
+          end
+
+          down(box)
+        end
+
+        return false if exit_codes.include?(false)
+        true
+      end
+    end
+  end
+end

data/lib/gonzo/rake_tasks.rb

@@ -0,0 +1,10 @@
+require 'rake'
+require 'gonzo'
+require 'rake/tasklib'
+
+desc "Run Gonzo"
+task :gonzo do
+  config = Gonzo.config(Dir.pwd)
+  gonzo = Gonzo::Runner.new(config)
+  gonzo.run
+end

data/lib/gonzo/runner.rb

@@ -0,0 +1,55 @@
+require 'yaml'
+require 'fileutils'
+require 'gonzo/providers'
+
+module Gonzo
+  class Runner
+    attr_reader :statedir, :config, :global
+
+    def initialize(config)
+      @config = config
+      @global = config['gonzo']
+    end
+
+    def supported_providers
+      %w(vagrant)
+    end
+
+    def providers
+      return @providers if @providers
+      @providers = []
+      provs = config.select { |k,v| k unless k == 'gonzo' }
+      provs.each do |provider,config|
+        unless supported_providers.include?(provider)
+          puts "Provider #{provider} is not implemented!"
+          break
+        end
+        @providers << Gonzo::Providers::Vagrant.new(config, global)
+      end
+      @providers
+    end
+
+    def cleanup
+      return if global['cleanup'] == false
+      providers.each(&:cleanup)
+      FileUtils.rm_r global['statedir']
+    end
+
+    def run
+      exit_codes = []
+      providers.each do |provider|
+        status = provider.run
+
+        exit_codes << status
+
+        if config['gonzo']['stop_on_failure']
+          exit status unless status
+        end
+      end
+
+      status = exit_codes.include?(false) ? false : true
+      cleanup
+      exit status
+    end
+  end
+end

data/lib/gonzo/version.rb

@@ -0,0 +1,3 @@
+module Gonzo
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: gonzo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Danzilio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+description: |2
+      This Gem lets you programmatically spin up a Vagrant box and run a set of
+      commands in the root of your project. This can be useful for running RSpec
+      or ServerSpec tests.
+email: david@danzilio.net
+executables:
+- gonzo
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/gonzo
+- lib/gonzo.rb
+- lib/gonzo/providers.rb
+- lib/gonzo/providers/vagrant.rb
+- lib/gonzo/rake_tasks.rb
+- lib/gonzo/runner.rb
+- lib/gonzo/version.rb
+homepage: https://github.com/danzilio/gonzo
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.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: A simpler Muppet for simpler Puppets
+test_files: []
+has_rdoc: