finger-puppet 0.3.0

data/features/step_definitions/finger-puppet_steps.rb

@@ -0,0 +1,149 @@
+Given /^I am working in "([^\"]*)"$/ do |directory|
+  @basedir = Pathname.new(directory)
+end
+
+Given /^I have an empty git repository named "([^\"]*)"$/ do |repo_name|
+  repo_path = @basedir.join(repo_name)
+  FileUtils.rm_rf(repo_path)
+  FileUtils.mkdir_p(repo_path)
+
+  Dir.chdir(repo_path) do
+    commands = [ "git init -q",
+                 "touch foo",
+                 "git add foo",
+                 "git commit -qm 'init' ." ]
+    commands.each do |command|
+      system(command).should be_true
+    end
+  end
+
+  File.exists?(repo_path.join('.git')).should be_true
+end
+
+When /^I run "([^\"]*)"$/ do |cmd|
+  if cmd.split(' ').first == "finger-puppet"
+    command = %w(ruby -rubygems)
+    command << ROOT.join('bin', 'finger-puppet')
+    command << cmd.split[1..-1].join(' ')
+    command = command.join(' ')
+  else
+    command = cmd
+  end
+
+  Dir.chdir(@basedir) do
+    system(command).should be_true
+  end
+end
+
+Then /^running "([^\"]*)" should fail$/ do |command|
+  Dir.chdir(@basedir) do
+    system(command).should be_false
+  end
+end
+
+Then /^running "([^\"]*)" should succeed$/ do |command|
+  Dir.chdir(@basedir) do
+    system(command).should be_true
+  end
+end
+
+Then /^running "([^\"]*)" should output "([^\"]*)"$/ do |cmd, string|
+  if cmd.split(' ').first == "finger-puppet"
+    command = %w(ruby -rubygems)
+    command << ROOT.join('bin', 'finger-puppet')
+    command << cmd.split[1..-1].join(' ')
+    command = command.join(' ')
+  else
+    command = cmd
+  end
+
+  Dir.chdir(@basedir) do
+    (`#{command}` =~ /#{string}/).should be_true
+  end
+end
+
+Then /^I should have a git repository at "([^\"]*)"$/ do |repo_name|
+  repo_path = @basedir.join(repo_name)
+  File.exists?(repo_path.join('.git')).should be_true
+end
+
+Given /^there is no "([^\"]*)" repository$/ do |repo_name|
+  repo_path = @basedir.join(repo_name)
+  FileUtils.rm_rf(repo_path)
+end
+
+Given /^I have a simple Puppet repository named "([^\"]*)"$/ do |repo_name|
+  repo_path = @basedir.join(repo_name)
+  simple_path = ROOT.join('features', 'support', 'repos', 'simple')
+  hostname = Socket.gethostname.split('.').first
+
+  FileUtils.rm_rf(repo_path)
+  FileUtils.cp_r(simple_path, repo_path)
+
+  File.open(repo_path.join('manifests', 'nodes', "#{hostname}.pp"), 'w') do |f|
+    f << "node #{hostname} { include 'test' }"
+  end
+
+  Dir.chdir(repo_path) do
+    commands = ["git init -q", "git add .", "git commit -qm 'init' ."]
+    commands.each do |command|
+      system(command).should be_true
+    end
+  end
+
+  File.exists?(repo_path.join('.git')).should be_true
+end
+
+Given /^I have a simple Puppet 2.6 repository named "([^"]*)"$/ do |repo_name|
+  repo_path = @basedir.join(repo_name)
+  simple_path = ROOT.join('features', 'support', 'repos', 'simple_26')
+  hostname = Socket.gethostname.split('.').first
+
+  FileUtils.rm_rf(repo_path)
+  FileUtils.cp_r(simple_path, repo_path)
+
+  File.open(repo_path.join('manifests', 'nodes', "#{hostname}.pp"), 'w') do |f|
+    f << "node #{hostname} { include 'test' }"
+  end
+
+  Dir.chdir(repo_path) do
+    commands = ["git init -q", "git add .", "git commit -qm 'init' ."]
+    commands.each do |command|
+      system(command).should be_true
+    end
+  end
+
+  File.exists?(repo_path.join('.git')).should be_true
+end
+
+Then /^I should see a file at "([^\"]*)"$/ do |path|
+  File.exists?(path).should be_true
+end
+
+Then /^I should see a directory at "([^\"]*)"$/ do |path|
+  File.directory?(path).should be_true
+end
+
+Given /^there is no "([^\"]*)" file$/ do |file|
+  FileUtils.rm_rf(file).should be_true
+end
+
+Given /^"([^\"]*)" is on my path$/ do |command|
+  system("which #{command} > /dev/null").should be_true
+end
+
+Then /^I should see the following directories:$/ do |table|
+  table.hashes.each do |attrs|
+    File.directory?(attrs["directory"]).should be_true
+  end
+end
+
+When /^I touch "([^\"]*)"$/ do |filename|
+  system("touch #{filename} > /dev/null").should be_true
+end
+
+When /^the Gemfile looks like this:$/ do |string|
+  File.open(@basedir + 'Gemfile', 'w') do |f|
+    f << string + "\n"
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'pathname'
+
+ROOT = Pathname.new(File.expand_path(File.join(File.dirname(__FILE__), '..', '..')))
+
+def silent_system(cmd)
+  command = [cmd, "2>&1 /dev/null"]
+  system(command)
+end

data/features/support/repos/simple/Gemfile

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+source :rubygems
+
+gem "puppet"

data/features/support/repos/simple/manifests/site.pp

@@ -0,0 +1 @@
+import "nodes/*"

data/features/support/repos/simple/modules/test/manifests/init.pp

@@ -0,0 +1,5 @@
+class test {
+  file { "/tmp/checkout":
+    content => "checkout"
+  }
+}

data/features/support/repos/simple_26/manifests/site.pp

@@ -0,0 +1 @@
+import "nodes/*"

data/features/support/repos/simple_26/modules/test/manifests/init.pp

@@ -0,0 +1,5 @@
+class test($path="/tmp/checkout") {
+  file { "$path":
+    source  => "puppet:///modules/test/checkout"
+  }
+}

data/finger-puppet.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "finger-puppet"
+  s.version     = "0.3.0"
+  s.authors     = ["Anthony Somerset"]
+  s.email       = ["anthony@somersettechsolutions.co.uk"]
+  s.homepage    = "http://github.com/anthonysomerset/finger-puppet"
+  s.summary     = %q{finger-puppet helps you run Puppet locally against a Git checkout.}
+  s.description = %q{finger-puppet helps you run Puppet locally against a Git checkout. This is great for locally iterating your Puppet manifests very quickly, then pushng them up to a repository somewhere else to share the changes.}
+
+  s.rubyforge_project = "finger-puppet"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'thor', '0.13.4'
+  s.add_dependency 'bundler'
+
+  s.add_development_dependency 'puppet'
+  s.add_development_dependency 'cucumber'
+end

data/lib/finger-puppet.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'pathname'
+
+module Logging
+  ESCAPES = { :green  => "\033[0;32m",
+              :yellow => "\033[0;33m",
+              :red    => "\033[47;31m",
+              :reset  => "\033[0m" }
+
+  def info(message)
+    emit(:message => message, :color => :green)
+  end
+
+  def warn(message)
+    emit(:message => message, :color => :yellow)
+  end
+
+  def error(message)
+    emit(:message => message, :color => :red)
+  end
+
+  def emit(opts={})
+    color   = opts[:color]
+    message = opts[:message]
+    print ESCAPES[color]
+    print message
+    print ESCAPES[:reset]
+    print "\n"
+  end
+end
+
+# Thor's default stack trace on errors is ugly - make it pretty.
+class Thor
+  class << self
+    def handle_argument_error(task, error)
+      puts "#{task.name.inspect} was called incorrectly. Call as #{task.formatted_usage(self, banner_base == "thor").inspect}."
+      exit 1
+    end
+  end
+end
+
+
+class finger-puppet < Thor
+  include Logging
+
+  def initialize
+    super
+    @root = Pathname.new(Dir.getwd)
+    @install_root = Pathname.new(File.expand_path(File.join(File.dirname(__FILE__))))
+  end
+
+  desc "clone <repository> [directory]", "clone a Git repository of Puppet manifests"
+  def clone(repository, directory=nil)
+    abort_unless_git_installed
+    directory ||= File.basename(repository.split('/').last, '.git')
+    command = "git clone -q #{repository} #{directory}"
+    system(command)
+
+    # A cloned repo may have submodules - automatically initialise them.
+    if File.exists?(File.join(directory, '.gitmodules'))
+      Dir.chdir(directory) do
+        system("git submodule init")
+        system("git submodule update")
+      end
+    end
+  end
+
+  desc "go [puppet arguments]", "do a local Puppet run"
+  def go(*puppet_args)
+    if ENV['USER'] != "root"
+      warn "You should probably be root when running this! Proceeding anyway..."
+    end
+
+    args = []
+    if has_frozen_components?
+      args << "bundle exec puppet"
+      info "Using frozen Puppet from #{@root.join('vendor', 'puppet')}."
+    else
+      abort_unless_puppet_installed(:message => "Please either install it on your system or freeze it with 'finger-puppet freeze'")
+      args << "puppet"
+    end
+
+    if puppet_version[0] > 0
+      args << 'apply'
+    end
+
+    args << "--modulepath #{@root.join('modules')}"
+    args << "--confdir #{@root.join('etc')}" unless puppet_args.include?("--confdir")
+    args << "--vardir #{@root.join('var')}" unless puppet_args.include?("--vardir")
+    args << "#{@root.join('manifests', 'site.pp')}"
+
+    args += puppet_args
+
+    command = args.join(' ')
+    puts command if args.include?("--debug")
+    system(command) ? exit(0) : exit(2)
+  end
+
+  desc "freeze [repository, project]", "freeze Puppet into your manifests repository"
+  def freeze(*args)
+    abort_unless_git_installed
+    abort_unless_bundle_installed
+
+    commands = []
+    commands << { :command => "bundle install --path=#{@root + 'vendor'} --binstubs" }
+    commands << { :command => "git add Gemfile.lock bin/ vendor/ .bundle/" }
+    commands << { :command => "git commit --quiet -m 'Bundled Puppet + Facter.' Gemfile* bin/ vendor/ .bundle/" }
+
+    commands.each do |attrs|
+      dir = attrs[:directory] || @root
+      Dir.chdir(dir) do
+        exit(2) unless system(attrs[:command])
+      end
+    end
+
+    info "Freezing complete."
+  end
+
+  desc "scaffold <project>", "generate scaffolding for a repository of Puppet manifests"
+  def scaffold(puppet_path)
+    template_path = @install_root.join('generators', 'puppet')
+    FileUtils.cp_r(template_path, puppet_path)
+  end
+
+  desc "init <project>", "initialise a repo of scaffolded Puppet manifests"
+  def init(project)
+    repo_path = @root.join(project)
+    template_path = @install_root.join('generators', 'git')
+
+    scaffold(repo_path)
+
+    Dir.chdir(repo_path) do
+      commands = [ "git init --quiet --template=#{template_path}",
+                   "git add .",
+                   "git commit --quiet -am 'Initial commit.'" ]
+      commands.each do |command|
+        system(command)
+      end
+    end
+
+    info "Your new finger-puppet project has been initialised in #{repo_path}"
+  end
+
+  desc "whoami [rfc2822-address]", "set the current commit author"
+  def whoami(address=nil)
+    # getter
+    if address
+      name  = address[/^(.+)\s+</, 1]
+      email = address[/<(.+)>$/, 1]
+
+      unless name && email
+        abort("Supplied address isn't a valid rfc2822 email address")
+      end
+
+      system("git config user.name '#{name}'")
+      system("git config user.email '#{email}'")
+    # setter
+    else
+      name  = `git config user.name`.strip
+      email = `git config user.email`.strip
+
+      if name.empty? || email.empty?
+        warn "You don't have a name or email set."
+      else
+        puts "#{name} <#{email}>"
+      end
+    end
+  end
+
+  private
+  def has_frozen_components?
+    puppet = system("bundle show puppet")
+    facter = system("bundle show facter")
+
+    puppet && facter
+  end
+
+  def puppet_version
+    @puppet_version ||= `puppet --version`.split('.').map(&:to_i)
+  end
+
+  # helper + abortive methods
+  %w(puppet git bundle).each do |bin|
+    class_eval <<-METHOD, __FILE__, __LINE__
+      no_tasks do
+        def #{bin}_installed?
+          `which #{bin}` =~ /#{bin}$/ ? true : false
+        end
+
+        def abort_unless_#{bin}_installed(opts={})
+          unless #{bin}_installed?
+            error "You don't have #{bin.capitalize} installed!"
+            error opts[:message] || "Please install it on your system."
+            exit 3
+          end
+        end
+      end
+    METHOD
+  end
+
+end
+

data/lib/generators/git/description

@@ -0,0 +1 @@
+a finger-puppet-ified repository of Puppet manifests

data/lib/generators/git/hooks/pre-commit

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require "socket"
+
+name     = ENV['GIT_AUTHOR_NAME']  || `git config user.name`
+email    = ENV['GIT_AUTHOR_EMAIL'] || `git config user.email`
+hostname = Socket.gethostname
+
+@errors = []
+case 
+when !name, name.strip.empty?
+  @errors << "You don't have an author name set."
+  @errors << "Please set this to your real name before committing."
+when !email, email.strip.empty?
+  @errors << "You don't have an author email address set."
+  @errors << "Please set this to your real email address before committing."
+when name == "root", name =~ /^\s*$/
+  @errors << "Your author name is '#{name}'."
+  @errors << "Please set this to your real name before committing."
+when email =~ /^\s*$/, email =~ /#{hostname}/
+  @errors << "You author email is '#{email}'."
+  @errors << "This matches part of the system hostname (#{hostname})."
+  @errors << "If this is correct, please run again with --no-verify."
+end
+
+if @errors.size > 0
+  puts @errors
+  exit 1 
+end

data/lib/generators/git/info/exclude

@@ -0,0 +1,6 @@
+# git-ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

data/lib/generators/puppet/.gitignore

@@ -0,0 +1,2 @@
+var/state/
+var/reports/

data/lib/generators/puppet/Gemfile

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+source :rubygems
+
+gem 'puppet'
+gem 'facter'

data/lib/generators/puppet/README.md

@@ -0,0 +1,27 @@
+Manifests
+=========
+
+modules/ <= Puppet modules
+manifests/ <= Puppet nodes
+vendor/ <= frozen Puppet + Facter
+
+
+Running Puppet with finger-puppet
+------------------------
+
+From within this directory, run:
+
+    finger-puppet go
+
+You can pass options to Puppet after the 'go':
+
+    finger-puppet go --debug --test
+
+Freezing Puppet
+---------------
+
+You can freeze Puppet:
+
+    finger-puppet freeze
+
+Now finger-puppet will use the frozen Puppet when you run 'finger-puppet go'.

data/lib/generators/puppet/etc/puppet.conf

@@ -0,0 +1,2 @@
+[main]
+show_diff = true

data/lib/generators/puppet/manifests/nodes.pp

@@ -0,0 +1 @@
+# Put yur nodes here!

data/lib/generators/puppet/manifests/site.pp

@@ -0,0 +1,8 @@
+import "nodes"
+
+filebucket { main: server => puppet }
+
+File { backup => main }
+
+Exec { path => "/usr/bin:/usr/sbin:/bin:/sbin" }
+