soloist-rvm 0.0.1

data/lib/soloist/config.rb

@@ -0,0 +1,118 @@
+require "soloist/royal_crown"
+require "tempfile"
+
+module Soloist
+  class Config
+    attr_writer :solo_rb_path, :node_json_path
+    attr_reader :royal_crown
+
+    def self.from_file(royal_crown_path)
+      rc = Soloist::RoyalCrown.from_file(royal_crown_path)
+      new(rc)
+    end
+
+    def initialize(royal_crown)
+      @royal_crown = royal_crown
+    end
+
+    def run_chef
+      exec(conditional_sudo("bash -c '#{chef_solo}'"))
+    end
+
+    def chef_solo
+      "chef-solo -c '#{solo_rb_path}' -l '#{log_level}'"
+    end
+
+    def as_solo_rb
+      <<-SOLO_RB
+        file_cache_path "#{chef_cache_path}"
+        cookbook_path #{cookbook_paths.inspect}
+        json_attribs "#{node_json_path}"
+      SOLO_RB
+    end
+
+    def as_node_json
+      compiled.node_attributes.to_hash.merge({ "recipes" => compiled.recipes })
+    end
+
+    def chef_cache_path
+      "/var/chef/cache".tap do |cache_path|
+        system(conditional_sudo("mkdir -p #{cache_path}")) \
+          unless File.directory?(cache_path)
+      end
+    end
+
+    def cookbook_paths
+      ([royal_crown_cookbooks_directory] + compiled.cookbook_paths).map do |path|
+        File.expand_path(path, royal_crown_path)
+      end.uniq.select do |path|
+        File.directory?(path)
+      end
+    end
+
+    def solo_rb_path
+      @solo_rb_path ||= Tempfile.new(["solo", ".rb"]).tap do |file|
+        puts as_solo_rb if debug?
+        file.write(as_solo_rb)
+        file.close
+      end.path
+    end
+
+    def node_json_path
+      @node_json_path ||= Tempfile.new(["node", ".json"]).tap do |file|
+        puts JSON.pretty_generate(as_node_json) if debug?
+        file.write(JSON.dump(as_node_json))
+        file.close
+      end.path
+    end
+
+    def merge!(other)
+      royal_crown.recipes += other.royal_crown.recipes
+      royal_crown.cookbook_paths += other.royal_crown.cookbook_paths
+      royal_crown.node_attributes.merge!(other.royal_crown.node_attributes)
+      royal_crown.env_variable_switches.merge!(other.royal_crown.env_variable_switches)
+    end
+
+    def compiled
+      @compiled ||= royal_crown.dup.tap do |rc|
+        while rc["env_variable_switches"]
+          rc.delete("env_variable_switches").each do |variable, switch|
+            switch.each do |value, inner|
+              rc.merge!(inner) if ENV[variable] == value
+            end
+          end
+        end
+      end
+    end
+
+    def log_level
+      ENV["LOG_LEVEL"] || "info"
+    end
+
+    def debug?
+      log_level == "debug"
+    end
+
+    private
+    def conditional_sudo(command)
+      sudo_command = rvm? ? "rvmsudo_secure_path=1 rvmsudo" : "sudo"
+      root? ? command : "#{sudo_command} -E #{command}"
+    end
+
+    def root?
+      Process.uid == 0
+    end
+
+    def rvm?
+      `which rvm`.length > 0
+    end
+
+    def royal_crown_cookbooks_directory
+      File.expand_path("cookbooks", royal_crown_path)
+    end
+
+    def royal_crown_path
+      File.dirname(royal_crown.path)
+    end
+  end
+end

data/lib/soloist/remote.rb

@@ -0,0 +1,66 @@
+require "net/ssh"
+require "shellwords"
+require "etc"
+
+module Soloist
+  class RemoteError < RuntimeError; end
+
+  class Remote
+    attr_reader :user, :host, :key, :timeout, :stdout, :stderr, :exitstatus
+    attr_writer :connection
+
+    def self.from_uri(uri, key = "~/.ssh/id_rsa")
+      parsed = URI.parse("ssh://#{uri}")
+      new(parsed.user || Etc.getlogin, parsed.host, key)
+    end
+
+    def initialize(user, host, key, options = {})
+      @user = user
+      @host = host
+      @key = key
+      @timeout = options[:timeout] || 10000
+    end
+
+    def backtick(command)
+      @stdout = ""
+      @stderr = ""
+      exec(command)
+      @stdout
+    end
+
+    def system(command)
+      @stdout = STDOUT
+      @stderr = STDERR
+      exec(command)
+      exitstatus
+    end
+
+    def system!(*command)
+      system(*command).tap do |status|
+        raise RemoteError.new("#{command.join(" ")} exited #{status}") unless status == 0
+      end
+    end
+
+    def upload(from, to, opts = "--exclude .git")
+      Kernel.system("rsync -e 'ssh -i #{key}' -avz --delete #{from} #{user}@#{host}:#{to} #{opts}")
+    end
+
+    private
+    def connection
+      @connection ||= Net::SSH.start(host, user, :keys => [key], :timeout => timeout)
+    end
+
+    def exec(*command)
+      connection.open_channel do |channel|
+        channel.exec(*command) do |stream, success|
+          raise RemoteError.new("Could not run #{command.join(" ")}") unless success
+          stream.on_data { |_, data| stdout << data }
+          stream.on_extended_data { |_, type, data| stderr << data }
+          stream.on_request("exit-status") { |_, data| @exitstatus = data.read_long }
+        end
+      end
+      connection.loop
+      @exitstatus ||= 0
+    end
+  end
+end

data/lib/soloist/remote_config.rb

@@ -0,0 +1,62 @@
+require "soloist/config"
+require "soloist/remote"
+
+module Soloist
+  class RemoteConfig < Config
+    attr_reader :remote
+
+    def self.from_file(royal_crown_path, remote)
+      rc = Soloist::RoyalCrown.from_file(royal_crown_path)
+      new(rc, remote)
+    end
+
+    def initialize(royal_crown, remote)
+      @royal_crown = royal_crown
+      @remote = remote
+    end
+
+    def run_chef
+      remote.system!(conditional_sudo(%(/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("/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("/bin/mkdir -m 777 -p #{path}"))
+      end
+    end
+
+    def cookbook_paths
+      @cookbook_paths ||= ["/var/chef/cookbooks".tap do |remote_path|
+        remote.system!(conditional_sudo("/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/sudo -E #{command}"
+    end
+
+    def root?
+      remote.user == "root"
+    end
+  end
+end

data/lib/soloist/royal_crown.rb

@@ -0,0 +1,56 @@
+require "hashie"
+
+module Soloist
+  class RoyalCrown < Hashie::Trash
+    property :path
+    property :recipes, :default => []
+    property :cookbook_paths, :default => []
+    property :node_attributes, :default => Hashie::Mash.new,
+             :transform_with => lambda { |v| Hashie::Mash.new(v) }
+    property :env_variable_switches, :default => Hashie::Mash.new,
+             :transform_with => lambda { |v| Hashie::Mash.new(v) }
+
+    def node_attributes=(hash)
+      self["node_attributes"] = Hashie::Mash.new(hash)
+    end
+
+    def env_variable_switches=(hash)
+      self["env_variable_switches"] = Hashie::Mash.new(hash)
+    end
+
+    def to_yaml
+      to_hash.tap do |hash|
+        hash.delete("path")
+        self.class.nilable_properties.each { |k| hash[k] = nil if hash[k].empty? }
+      end
+    end
+
+    def save
+      return self unless path
+      File.open(path, "w+") { |file| file.write(YAML.dump(to_yaml)) }
+      self
+    end
+
+    def reload
+      self.class.from_file(path)
+    end
+
+    def self.from_file(file_path)
+      new(read_config(file_path).merge("path" => file_path))
+    end
+
+    def self.read_config(yaml_file)
+      content = File.read(yaml_file)
+      YAML.load(ERB.new(content).result).tap do |hash|
+        nilable_properties.each do |key|
+          hash.delete(key) if hash[key].nil?
+        end if hash
+      end || {}
+    end
+
+    private
+    def self.nilable_properties
+      (properties - [:path]).map(&:to_s)
+    end
+  end
+end

data/lib/soloist/spotlight.rb

@@ -0,0 +1,41 @@
+require 'pathname'
+
+module Soloist
+  class NotFound < RuntimeError; end
+
+  class Spotlight
+    attr_reader :pathname
+
+    def self.find(*file_names)
+      new(Dir.pwd).find(*file_names)
+    end
+
+    def self.find!(*file_names)
+      new(Dir.pwd).find!(*file_names)
+    end
+
+    def initialize(path)
+      @pathname = Pathname.new(path)
+    end
+
+    def find(*file_names)
+      pathname.ascend do |path|
+        file_name = file_names.detect { |fn| path.join(fn).file? }
+        break path.join(file_name) if file_name
+      end
+    end
+
+    def find!(*file_names)
+      file_path = find(*file_names)
+      unless file_path
+        file_names = if file_names.length > 2
+          file_names[0...-1].join(", ") + " or " + file_names.last
+        else
+          file_names.join(" or ")
+        end
+        raise Soloist::NotFound.new("Could not find #{file_names}")
+      end
+      file_path
+    end
+  end
+end

data/lib/soloist/version.rb

@@ -0,0 +1,3 @@
+module Soloist
+  VERSION = "0.0.1"
+end

data/script/bootstrap.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+set -e
+
+echo "Updating package list"
+sudo apt-get update > /dev/null
+
+echo "Ensuring curl is available"
+sudo apt-get install -y curl > /dev/null
+
+echo "Setting up RVM"
+
+user=$1
+[ -z "$user" ] && user="ubuntu"
+
+test -d /usr/local/rvm || curl -L https://get.rvm.io | sudo bash -s stable
+
+test -e /usr/local/rvm || sudo tee /etc/profile.d/rvm.sh > /dev/null <<RVMSH_CONTENT
+[[ -s "/usr/local/rvm/scripts/rvm" ]] && source "/usr/local/rvm/scripts/rvm"
+RVMSH_CONTENT
+
+test -x /usr/local/rvm || sudo chmod +x /etc/profile.d/rvm.sh
+
+grep "^$user:" /etc/passwd > /dev/null || sudo useradd -m $user -G sudo,rvm,admin -s /bin/bash
+
+test -e /etc/rvmrc || sudo tee /etc/rvmrc > /dev/null <<RVMRC_CONTENTS
+rvm_install_on_use_flag=1
+rvm_trust_rvmrcs_flag=1
+rvm_gemset_create_on_use_flag=1
+RVMRC_CONTENTS
+
+echo "Detecting RVM requirements"
+
+bash -lc 'rvm requirements' | tee /tmp/rvm-requirements > /dev/null
+packages=`grep "  ruby: /usr/bin/apt-get install" /tmp/rvm-requirements | sed "s/  ruby: \/usr\/bin\/apt-get install //g"`
+
+echo "Detected RVM requirements: $packages"
+
+selections=`dpkg --get-selections`
+for package in $packages
+do
+  if ! echo "$selections" | grep "^$package\s" > /dev/null
+  then
+    to_install="$to_install $package"
+  fi
+done
+
+if [ -z "$to_install" ]
+then
+  echo "Satisfied RVM requirements"
+else
+  echo "Installing missing RVM requirements: $to_install"
+  sudo apt-get install -y $to_install
+fi

data/script/ci.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bundle exec rspec

data/soloist-rvm.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "soloist/version"
+
+Gem::Specification.new do |s|
+  s.name        = "soloist-rvm"
+  s.version     = Soloist::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Austin Putman"]
+  s.email       = ["austin@rawfingertips.com"]
+  s.homepage    = "http://github.com/austinfromboston/soloist"
+  s.summary     = "Soloist-rvm is a way of running chef-solo under rvm"
+  s.description = "Makes running chef-solo possible."
+
+  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 "chef"
+  s.add_dependency "librarian"
+  s.add_dependency "thor"
+  s.add_dependency "hashie", "~> 1.2"
+  s.add_dependency "net-ssh"
+  s.add_dependency "awesome_print"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "guard-bundler"
+  s.add_development_dependency "guard-shell"
+  s.add_development_dependency "rb-fsevent"
+  s.add_development_dependency "terminal-notifier-guard"
+  s.add_development_dependency "gem-release"
+end