stackadmin 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9356c67e44d2b41f466700e39b383e6ddf8599d9
+  data.tar.gz: 90080f91deaa13008ee34454051567d44c1ee291
+SHA512:
+  metadata.gz: 7cdf3b9b5f4f8157f00c5d3826ea8643fdae871c4105004e0ae11ec8910b14c1b4a448f1b1c17fdeb61a5c60b85c70837f27d082b6dca0416d7d85c836abb058
+  data.tar.gz: 4925bc36f4ab907e38ee5fc41b4aa2d553fe1b615685d7d26040ffa2e77e2b352bde2bd1604b7f887abf738e5d07e7b28473103e78d866aecfb3c27ec9143ba2

data/.gitignore

@@ -0,0 +1 @@
+test/.vagrant

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gem 'net-ssh'
+gem 'json'
+
+group :development do
+  gem 'minitest'
+  gem 'minitest-reporters'
+  gem 'vagrant', git: 'https://github.com/mitchellh/vagrant.git'
+end
+
+group :plugins do
+  gem 'vagrant-s3auth'
+end

data/Gemfile.lock

@@ -0,0 +1,119 @@
+GIT
+  remote: https://github.com/mitchellh/vagrant.git
+  revision: b2c722ef54e57c9de5cdbe712b27e52faacec5da
+  specs:
+    vagrant (1.7.2)
+      bundler (>= 1.5.2, < 1.8.0)
+      childprocess (~> 0.5.0)
+      erubis (~> 2.7.0)
+      hashicorp-checkpoint (~> 0.1.1)
+      i18n (~> 0.6.0)
+      listen (~> 2.8.0)
+      log4r (~> 1.1.9, < 1.1.11)
+      net-scp (~> 1.1.0)
+      net-sftp (~> 2.1)
+      net-ssh (>= 2.6.6, < 2.10.0)
+      nokogiri (= 1.6.3.1)
+      rb-kqueue (~> 0.2.0)
+      rest-client (>= 1.6.0, < 2.0)
+      wdm (~> 0.1.0)
+      winrm (~> 1.3.0)
+      winrm-fs (~> 0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    aws-sdk (1.59.1)
+      aws-sdk-v1 (= 1.59.1)
+    aws-sdk-v1 (1.59.1)
+      json (~> 1.4)
+      nokogiri (>= 1.4.4)
+    builder (3.2.2)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    childprocess (0.5.5)
+      ffi (~> 1.0, >= 1.0.11)
+    erubis (2.7.0)
+    ffi (1.9.6)
+    gssapi (1.2.0)
+      ffi (>= 1.0.1)
+    gyoku (1.2.2)
+      builder (>= 2.1.2)
+    hashicorp-checkpoint (0.1.4)
+    hashie (3.4.0)
+    hitimes (1.2.2)
+    httpclient (2.6.0.1)
+    i18n (0.6.11)
+    json (1.8.2)
+    listen (2.8.5)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    little-plugger (1.1.3)
+    log4r (1.1.10)
+    logging (1.8.2)
+      little-plugger (>= 1.1.3)
+      multi_json (>= 1.8.4)
+    mime-types (2.4.3)
+    mini_portile (0.6.0)
+    minitest (4.3.2)
+    minitest-reporters (0.14.24)
+      ansi
+      builder
+      minitest (>= 2.12, < 5.0)
+      powerbar
+    multi_json (1.10.1)
+    net-scp (1.1.2)
+      net-ssh (>= 2.6.5)
+    net-sftp (2.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.9.2)
+    netrc (0.10.2)
+    nokogiri (1.6.3.1)
+      mini_portile (= 0.6.0)
+    nori (2.4.0)
+    powerbar (1.0.12)
+      ansi (~> 1.5.0)
+      hashie (>= 1.1.0)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.3)
+      ffi (>= 0.5.0)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rubyntlm (0.4.0)
+    rubyzip (1.1.7)
+    timers (4.0.1)
+      hitimes
+    uuidtools (2.1.5)
+    vagrant-s3auth (1.0.2)
+      aws-sdk (~> 1.59.1)
+    wdm (0.1.0)
+    winrm (1.3.0)
+      builder (>= 2.1.2)
+      gssapi (~> 1.2)
+      gyoku (~> 1.0)
+      httpclient (~> 2.2, >= 2.2.0.2)
+      logging (~> 1.6, >= 1.6.1)
+      nori (~> 2.0)
+      rubyntlm (~> 0.4.0)
+      uuidtools (~> 2.1.2)
+    winrm-fs (0.1.0)
+      erubis (~> 2.7)
+      logging (~> 1.6, >= 1.6.1)
+      rubyzip (~> 1.1)
+      winrm (~> 1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json
+  minitest
+  minitest-reporters
+  net-ssh
+  vagrant!
+  vagrant-s3auth

data/README.md

@@ -0,0 +1,2 @@
+# stackadmin
+Gem to facilitate administration of Stackato deployments

data/Rakefile

@@ -0,0 +1,37 @@
+# Encoding: utf-8
+require 'rake/testtask'
+
+task :default => 'test'
+
+namespace :test do
+  desc 'Spin up test env'
+  task :start_env  do
+    Dir.chdir('test') { system('bundle exec vagrant up') }
+  end
+
+  desc 'Setup test env'
+  task :setup, :pub_key_location do |t, args|
+    pub_key_location = args[:pub_key_location] || File.expand_path('~/.ssh/keys/id_rsa.pub')
+    pub_key = File.open(pub_key_location, 'r').read
+    Dir.chdir('test') { system("vagrant ssh --command 'echo \"#{pub_key}\" | sudo tee -a /home/stackato/.ssh/authorized_keys' > /dev/null") }
+  end
+
+  desc 'Destroy test env'
+  task :destroy_env do
+    Dir.chdir('test') { system('bundle exec vagrant destroy --force') }
+  end
+end
+
+Rake::TestTask.new('test:run') do |t|
+  t.test_files = FileList['test/*_test.rb']
+end
+
+desc 'Run all test tasks'
+task :test do
+  %w( start_env setup run destroy_env ).each do |j|
+    job = "test:#{j}"
+    puts "\e[35mRunning #{job}...\e[0m"
+    Rake::Task[job].invoke
+    puts
+  end
+end

data/lib/stackadmin/audit.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require_relative 'base'
+require_relative 'exceptions'
+require_relative 'net-ssh'
+
+class Stackadmin
+  private
+
+  def audit(target = @id)
+    @id = target
+    log "Auditing #{@id}"
+
+    begin
+      Net::SSH.start(target, 'stackato', port: @port) do |ssh|
+        @version = parse_version(ssh)
+        @license = parse_license(ssh)
+        @nodes = map_nodes(ssh)
+        parse_patch_status(ssh)
+        @fresh = true
+      end
+    rescue Net::SSH::Exception => e
+      log "#{@id} audit failed! #{e}"
+      @fresh = false
+    end
+  end
+
+  def parse_version(ssh)
+    cmd = ssh.exec_sc!('kato info | grep Version')
+    ver = cmd[:stdout].split.last
+    log "Retrieved version: #{ver}"
+
+    ver.gsub!(/v/, '') if ver =~ /^v\d.*$/
+    log "Parsed as version: #{ver}"
+
+    ver
+  end
+
+  def parse_license(ssh)
+    license = Hash.new
+
+    ssh.exec_sc!('kato config get cluster license')[:stdout].split("\n").each do |line|
+      line = line.split(': ')
+      license[line[0]] = line[1]
+    end
+
+    license
+  end
+
+  def map_nodes(ssh)
+    cluster = Hash.new
+
+    ssh.exec_sc!('kato node list')[:stdout].split("\n").each do |node|
+      n = node.split
+      cluster[n[0]] = { roles: n[1..-1] }
+    end
+
+    cluster
+  end
+
+  # TODO: It never seems to hit "Marked #{patch} as patched for #{k}"
+  def parse_patch_status(ssh)
+    # Initialize 'patched' hash for each cluster node
+    @nodes.each_value do |node|
+      node[:patched] = Hash.new
+      manifest['patches'].keys.each { |patch| node[:patched][patch] = true }
+    end
+
+    status = ssh.exec_sc!('kato patch status')[:stdout]
+    log "kato patch status:\n#{status}"
+
+    patches = hashify_patch_status(status)
+    patches.each do |patch, info|
+      if info.empty?
+        @nodes.each do |k, v|
+          v[:patched][patch] = false
+          log "Marked #{patch} as patched for #{k}."
+        end
+      elsif info.has_key?(:unpatched)
+        @nodes.each do |k, v|
+          v[:patched][patch] = false if info[:unpatched].include?(k)
+          log "Marked #{patch} as unpatched for #{k}."
+        end
+      end
+    end
+  end
+
+  def hashify_patch_status(status)
+    patches = Hash.new
+
+    unless status =~ /^No Stackato updates are available for #{@version}\.$/
+      status = strip_footer(strip_header(status)).split("\n\n")
+
+      status.each do |patch|
+        patch = patch.split("\n").map { |p| p.lstrip.split(': ') }
+        name = patch[0][0]
+        patches[name] = Hash.new
+
+        patch.each do |line|
+          if line[0] == 'to be installed on'
+            list = line[1].lstrip
+            patches[name][:unpatched] = (list == 'none') ? [] : list.split(', ')
+          end
+        end
+      end
+    end
+
+    patches
+  end
+
+  def strip_header(status)
+    log 'Stripping header'
+
+    s = status.split("\n")
+    major_ver = @version.to_i
+    header_end = case major_ver
+                 when 2
+                   /^Known updates for Stackato #{@version}:$/
+                 when 3
+                   /^\d+ updates are available for #{@version}.$/
+                 end
+
+    break if s.shift.match header_end until s.empty?
+    raise InvalidPatchStatus, "kato patch status:\n\n#{status}" if s.empty?
+
+    s.shift if major_ver == 3  # Strip superfluous leading empty line
+    s.join("\n")
+  end
+
+  def strip_footer(status)
+    log 'Stripping footer'
+
+    s = status.split("\n")
+    until s.empty?
+      line = s.pop
+      if line =~ /^\t+.+: .+$/
+        s << line
+        break
+      end
+    end
+
+    raise InvalidPatchStatus, "kato patch status:\n\n#{status}" if s.empty?
+    s.join("\n")
+  end
+end

data/lib/stackadmin/base.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'json'
+require 'open-uri'
+
+class Stackadmin
+  attr_reader :id, :version, :license, :nodes, :fresh
+
+  def initialize(target, port = 22, debug = false, yml_file = nil)
+    @port = port
+    @debug = debug
+    yml_file ? parse_yaml(target, yml_file) : audit(target)
+  end
+
+  def refresh(target = nil)
+    @id ||= target
+    audit
+  end
+
+  def self.find_instances(ssh_config = '~/.ssh/config', filter = [])
+    instances = IO.read(File.expand_path(ssh_config))
+                  .scan(/^\s*Host (.*stackato.*)/)
+                  .flatten
+    filter.each { |f| instances.delete_if { |host| host =~ /#{f}/ } }
+    instances
+  end
+
+  def manifest(uri = nil)
+    unless @manifest
+      uri ||= "https://get.stackato.com/kato-patch/#{@version}/manifest.json"
+      log "Retrieving latest manifest from: #{uri}"
+    end
+
+    @manifest ||= JSON.load(open(uri)) rescue nil
+  end
+
+  private
+
+  def log(msg)
+    $stderr.puts ">> #{msg}" if @debug
+  end
+end

data/lib/stackadmin/exceptions.rb

@@ -0,0 +1,16 @@
+class Stackadmin
+  class Exception < StandardError
+  end
+
+  class YAMLTargetNotFound < Stackadmin::Exception
+  end
+
+  class InvalidPatchStatus < Stackadmin::Exception
+  end
+
+  class InvalidFlags < Stackadmin::Exception
+  end
+
+  class InvalidCommand < Stackadmin::Exception
+  end
+end

data/lib/stackadmin/net-ssh.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'net/ssh'
+
+# Grab exit codes from remote commands
+# Yanked this from http://stackoverflow.com/a/13436242
+class Net::SSH::Connection::Session
+  class CommandFailed < Net::SSH::Exception
+  end
+
+  class CommandExecutionFailed < Net::SSH::Exception
+  end
+
+  def exec_sc!(command)
+    stdout_data, stderr_data = '', ''
+    exit_code, exit_signal = nil, nil
+    self.open_channel do |channel|
+      channel.exec(command) do |_, success|
+        raise CommandExecutionFailed, "Command \"#{command}\" was unable to execute" unless success
+
+        channel.on_data do |_, data|
+          stdout_data += data
+        end
+
+        channel.on_extended_data do |_, _, data|
+          stderr_data += data
+        end
+
+        channel.on_request('exit-status') do |_, data|
+          exit_code = data.read_long
+        end
+
+        channel.on_request('exit-signal') do |_, data|
+          exit_signal = data.read_long
+        end
+      end
+    end
+    self.loop
+
+    raise CommandFailed, "Command \"#{command}\" returned exit code #{exit_code}" unless exit_code == 0
+
+    {
+      stdout: stdout_data,
+      stderr: stderr_data,
+      exit_code: exit_code,
+      exit_signal: exit_signal
+    }
+  end
+end

data/lib/stackadmin/patch.rb

@@ -0,0 +1,232 @@
+# encoding: utf-8
+
+require_relative 'base'
+require_relative 'net-ssh'
+require_relative 'exceptions'
+require_relative 'audit'
+
+class Stackadmin
+  # Returns hash of hashes: { node1: { installed: [patch1], not_installed: [patch2] }, etc }
+  # TODO: DRY this with ::mark! & ::reinstall! & ::revert!
+  def install!(patches = [], node = nil, local = false, restart = true, force_update = false, manifest_file = nil)
+    status = Hash.new
+    output = patch('install', patches, node: node, local: local, no_restart: !restart, force_update: force_update, manifest: manifest_file)
+
+    output.each do |p|
+      p = p[:stdout]
+      log "Job output:\n#{p}"
+      p.gsub!(/\e\[\d+m/, '')    # Strip ASCII color
+
+      p.scan(/^Failed installing update (.+?) on (.+?)\.$/).each do |fp|
+        # fp = Array of failed patches
+        # e.g. [["patch1-name", "node1-ip"], ["patch2-name", "node2-ip"]]
+        status[fp[1]] = {
+          installed: [],
+          not_installed: []
+        } unless status.has_key?(fp[1])
+
+        status[fp[1]][:not_installed] << fp[0]
+      end
+
+      p.scan(/^Successfully installed update (.+?) on (.+?)\.$/).each do |sp|
+        # sp = Array of successful patches. See fp example above
+        status[sp[1]] = {
+          installed: [],
+          not_installed: []
+        } unless status.has_key?(sp[1])
+
+        status[sp[1]][:installed] << sp[0]
+      end
+    end
+
+    status
+  end
+
+  def reset!(node = nil, local = false)
+    output = patch('reset', [], node: node, local: local)
+    output[0][:stdout] =~ /^Updates state reset.$/ ? true : false
+  end
+
+  def update!(node = nil, local = false, manifest_file = nil)
+    output = v3_action_check('update') do
+               patch('update', [], node: node, local: local, manifest: manifest_file)
+             end
+
+    output[0][:stdout] =~ /^done!$/ ? true : false
+  end
+
+  # Returns hash: { node1: [patch1, patch2], etc }
+  # TODO: DRY this with ::install! & ::reinstall! & ::revert!
+  def mark!(patches = [], mark_installed = false, node = nil, local = false)
+    status = Hash.new
+    output = v3_action_check('mark') do
+               patch('mark', patches, node: node, local: local, mark_installed: mark_installed)
+             end
+
+    output.each do |p|
+      p = p[:stdout]
+      log "Job output:\n#{p}"
+      p.gsub!(/\e\[\d+m/, '')   # Strip ASCII color
+
+      p.scan(/^Successfully marked patch (.+?) as #{'not ' unless mark_installed}installed on (.+?)\.$/).each do |sp|
+        # sp = Array of successfully marked patches
+        # e.g. [["patch1-name", "node1-ip"], ["patch2-name", "node2-ip"]]
+        status[sp[1]] = Array.new unless status.has_key?(sp[1])
+        status[sp[1]] << sp[0]
+      end
+    end
+
+    status
+  end
+
+  # Returns hash of hashes: { node1: { installed: [patch1], not_installed: [patch2] }, etc }
+  # TODO: DRY this with ::install! & ::mark! & ::revert!
+  def reinstall!(patches = [], node = nil, local = false, restart = true, force_update = false, manifest_file = nil)
+    if patches.empty?
+      raise InvalidCommand, "kato patch reinstall requires a specific patchname!"
+    else
+      status = Hash.new
+      output = patch('reinstall', patches, node: node, local: local, no_restart: !restart, force_update: force_update, manifest: manifest_file)
+
+      output.each do |p|
+        p = p[:stdout]
+        log "Job output:\n#{p}"
+        p.gsub!(/\e\[\d+m/, '')    # Strip ASCII color
+
+        p.scan(/^Failed installing update (.+?) on (.+?)\.$/).each do |fp|
+          # fp = Array of failed patches
+          # e.g. [["patch1-name", "node1-ip"], ["patch2-name", "node2-ip"]]
+          status[fp[1]] = {
+            installed: [],
+            not_installed: []
+          } unless status.has_key?(fp[1])
+
+          status[fp[1]][:not_installed] << fp[0]
+        end
+
+        p.scan(/^Successfully installed update (.+?) on (.+?)\.$/).each do |sp|
+          # sp = Array of successful patches. See fp example above
+          status[sp[1]] = {
+            installed: [],
+            not_installed: []
+          } unless status.has_key?(sp[1])
+
+          status[sp[1]][:installed] << sp[0]
+        end
+      end
+
+      status
+    end
+  end
+
+  # Returns hash of hashes: { node1: { reverted: [patch1], not_reverted: [patch2], unable_to_revert: [patch3] }, etc }
+  # TODO: DRY this with ::install! & ::mark!
+  def revert!(patches = [], node = nil, local = false, restart = true, force_update = false, manifest_file = nil)
+    status = Hash.new
+    output = v3_action_check('revert') do
+               patch('revert', patches, node: node, local: local, no_restart: !restart, force_update: force_update, manifest: manifest_file)
+             end
+
+    output.each do |p|
+      p = p[:stdout]
+      log "Job output:\n#{p}"
+      p.gsub!(/\e\[\d+m/, '')    # Strip ASCII color
+
+      p.scan(/^Failed reverting update (.+?) on (.+?)\.$/).each do |fp|
+        # fp = Array of failed patches
+        # e.g. [["patch1-name", "node1-ip"], ["patch2-name", "node2-ip"]]
+        status[fp[1]] = {
+          reverted: [],
+          not_reverted: [],
+          unable_to_revert: []
+        } unless status.has_key?(fp[1])
+
+        status[fp[1]][:not_installed] << fp[0]
+      end
+
+      p.scan(/^Successfully reverted update (.+?) on (.+?)\.$/).each do |sp|
+        # sp = Array of successful patches. See fp example above
+        status[sp[1]] = {
+          reverted: [],
+          not_reverted: [],
+          unable_to_revert: []
+        } unless status.has_key?(sp[1])
+
+        status[sp[1]][:installed] << sp[0]
+      end
+    end
+
+    status
+  end
+
+  private
+
+  def v3_action_check(action)
+    if @version.to_i == 3
+      yield
+    else
+      raise InvalidCommand, "kato patch #{action} unavailable on Stackato v#{@version}!"
+    end
+  end
+
+  # Args:
+  # - action: string, required
+  # -- subcommand to use for 'kato patch'
+  # - patches: array
+  # -- list of patches to apply with action
+  # -- string accepted, but assumed to denote a single patch
+  # - opts: hash, optional
+  # -- flags/arguments to apply to the kato patch action
+  def patch(action, patches = [], opts = {})
+    raise InvalidFlags, "Can't target both #{opts[:node]} & \"local\"!" if (opts[:node] && opts[:local])
+
+    cmd = "kato patch #{action}"
+
+    if @version.to_i == 3
+      cmd += " --node #{opts[:node]}" if opts[:node]
+      cmd += " --manifest #{opts[:manifest]}" if opts[:manifest]
+      cmd += ' --force-update' if opts[:force_update]
+
+      if action == 'mark'
+        cmd += opts[:mark_installed] ? ' --installed' : ' --notinstalled'
+      end
+
+      if opts[:manifest] || opts[:force_update]
+        @manifest = nil
+        manifest(opts[:manifest])
+      end
+    end
+
+    cmd += ' --no-restart' if opts[:no_restart]
+    cmd += case @version.to_i
+           when 2
+             ' --only-this-node'
+           when 3
+             ' --local'
+           end if opts[:local]
+
+    patches = [patches] if patches.class == String
+    output = Array.new
+
+    begin
+      Net::SSH.start(@id, 'stackato', port: @port) do |ssh|
+        if patches.empty?
+          log "Starting job: #{cmd}"
+          output << ssh.exec_sc!(cmd)
+        else
+          patches.each do |patch|
+            log "Starting job: #{cmd} #{patch}"
+            output << ssh.exec_sc!("#{cmd} #{patch}")
+          end
+        end
+
+        parse_patch_status(ssh)
+      end
+    rescue Net::SSH::Exception => e
+      patches = patches.empty? ? '[all]' : patches.to_s
+      log "kato patch failed! \"#{cmd} #{patches}\" -- #{e}"
+    end
+
+    output
+  end
+end

data/lib/stackadmin/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+class Stackadmin
+  VERSION = '0.1.0'
+end

data/lib/stackadmin/yaml.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'yaml'
+require_relative 'exceptions'
+
+class Stackadmin
+  def to_yaml
+    { 'id'      => @id,
+      'version' => @version,
+      'license' => @license,
+      'nodes'   => @nodes }.to_yaml
+  end
+
+  private
+
+  def parse_yaml(target, yml_file)
+    instances = YAML.load(File.read(yml_file))
+
+    instances.each do |stk|
+      if stk['id'] == target
+        @id      = stk['id']
+        @version = stk['version']
+        @license = stk['license']
+        @nodes   = stk['nodes']
+        @fresh   = false
+        return true
+      end
+    end
+
+    raise YAMLTargetNotFound, "Could not find '#{target}' in #{yml_file}!"
+  end
+end

data/lib/stackadmin.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+#
+# Utility class for administering Stackato nodes & clusters.
+
+%w( version net-ssh base exceptions audit yaml patch ).each do |rb|
+  require_relative "stackadmin/#{rb}"
+end

data/test/Vagrantfile

@@ -0,0 +1,14 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+SSH_CONFIG = <<-EOS
+  Host *
+    StrictHostKeyChecking no
+    UserKnownHostsFile=/dev/null
+EOS
+
+Vagrant.configure(2) do |config|
+  config.vm.box = 'stackato-v3.4.2'
+  config.vm.box_url = 's3://deployination/stackato-v3.4.2.box'
+  config.vm.provision 'shell', inline: "echo '#{SSH_CONFIG}' > ~stackato/.ssh/config"
+end

data/test/stackadmin_test.rb

@@ -0,0 +1,325 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+require_relative '../lib/stackadmin'
+
+MiniTest::Reporters.use! [MiniTest::Reporters::SpecReporter.new]
+
+TEST_ENV = '127.0.0.1'
+
+describe Stackadmin do
+  subject { Stackadmin.new(TEST_ENV, 2222) }
+
+  describe 'instantiation' do
+    it 'requires a target argument' do
+      lambda { Stackadmin.new }.must_raise ArgumentError
+    end
+
+    it 'requires a valid target' do
+      lambda { Stackadmin.new('foobaz') }.must_raise SocketError
+    end
+
+    it 'can connect to a valid Stackato instance' do
+      subject.must_be_instance_of Stackadmin
+    end
+
+    it 'defaults to auditing a live deployment' do
+      assert subject.fresh
+    end
+  end
+
+  describe 'auditing' do
+    it 'retrieves the Stackato version' do
+      subject.version.must_equal '3.4.2'
+    end
+
+    it 'retrieves the active license info' do
+      subject.license.must_be_instance_of Hash
+      subject.license.must_be_empty
+    end
+
+    it 'retrieves the latest manifest from ActiveState' do
+      subject.manifest.must_be_instance_of Hash
+      subject.manifest['stackato_version'].must_equal subject.version
+      %w( kato_patch patches ).each do |k|
+        subject.manifest(k).must_be_instance_of Hash
+        subject.manifest(k).wont_be_empty
+      end
+    end
+
+    # TODO: We should be testing more than a single-node microcloud
+    describe 'nodes' do
+      it 'maps cluster nodes to a hash' do
+        subject.nodes.must_be_instance_of Hash
+        subject.nodes.size.must_equal 1
+      end
+
+      let(:local_node) { subject.nodes[TEST_ENV] }
+
+      it 'retrieves role info for each node' do
+        subject.nodes.each_value do |node|
+          node[:roles].must_be_instance_of Array
+          node[:roles].wont_be_empty
+        end
+
+        local_node[:roles].must_include 'base'
+        local_node[:roles].must_include 'primary'
+      end
+
+      it 'retrieves patch info for each node' do
+        subject.nodes.each_value do |node|
+          node[:patched].must_be_instance_of Hash
+          node[:patched].wont_be_empty
+        end
+      end
+    end
+  end
+
+  describe 'patching' do
+    describe 'install!' do
+      it 'all patches to all nodes by default' do
+        skip 'need to isolate environments for testing'
+
+        subject.nodes.each_value do |node|
+          node[:patched].each_value { |patch| refute patch }
+        end
+
+        subject.install!
+
+        subject.nodes.each_value do |node|
+          node[:patched].each_value { |patch| assert patch }
+        end
+      end
+
+      let(:local_node) { subject.nodes[TEST_ENV] }
+
+      it 'install one patch' do
+        skip 'need to isolate environments for testing'
+
+        patch = local_node[:patched].keys[0]
+        subject.nodes.each_value { |node| refute node[:patched][patch] }
+        subject.install! patch
+        subject.nodes.each_value { |node| assert node[:patched][patch] }
+      end
+
+      it 'install multiple patches' do
+        skip 'need to isolate environments for testing'
+
+        patches = local_node[:patched].keys[0..1]
+        patches.each do |patch|
+          subject.nodes.each_value { |node| refute node[:patched][patch] }
+        end
+
+        subject.install! patches
+
+        patches.each do |patch|
+          subject.nodes.each_value { |node| assert node[:patched][patch] }
+        end
+      end
+
+      it 'only to the local node' do
+        skip 'need to test multi-node clusters'
+
+        local_node[:patched].each_value { |patch| refute patch }
+        subject.install!([], nil, true)
+        local_node[:patched].each_value { |patch| assert patch }
+      end
+
+      it 'only to a specified node' do
+        skip 'need to test multi-node clusters'
+
+        local_node[:patched].each_value { |patch| refute patch }
+        subject.install!([], TEST_ENV)
+        local_node[:patched].each_value { |patch| assert patch }
+      end
+
+      it 'only to multiple specified nodes' do
+        skip 'Not implemented yet'
+
+        nodes = subject.nodes.keys[0..1]
+        nodes.each do |node|
+          node[:patched].each_value { |patch| refute patch }
+        end
+
+        subject.install!([], nodes)
+
+        nodes.each do |node|
+          node[:patched].each_value { |patch| assert patch }
+        end
+      end
+
+      it 'without restarting the node' do
+        skip 'need to isolate environments for testing'
+
+        subject.nodes.each_value do |node|
+          node[:patched].each_value { |patch| refute patch }
+        end
+
+        subject.install!([], nil, false, false)
+
+        subject.nodes.each_value do |node|
+          node[:patched].each_value { |patch| assert patch }
+        end
+      end
+
+      it 'detects a successful patch installation' do
+        skip
+      end
+
+      it 'detects a failed patch installation' do
+        skip
+      end
+    end
+
+    describe 'reset! marks all patches as uninstalled' do
+      it 'on all nodes by default' do
+        skip
+      end
+
+      it 'only on the local node' do
+        skip
+      end
+
+      it 'only on a specified node' do
+        skip
+      end
+
+      it 'only on multiple specified nodes' do
+        skip 'Not implemented yet'
+      end
+
+      it 'detects a successful reset' do
+        skip
+      end
+    end
+
+    describe 'update! refreshes the manifest' do
+      it 'on all nodes by default' do
+        skip
+      end
+
+      it 'only on the local node' do
+        skip
+      end
+
+      it 'only on a specified node' do
+        skip
+      end
+
+      it 'only on multiple specified nodes' do
+        skip 'Not implemented yet'
+      end
+
+      it 'detects a successful update' do
+        skip
+      end
+    end
+
+    describe 'mark!' do
+      describe 'uninstalled' do
+        it 'single patch on all nodes by default' do
+          skip
+        end
+
+        it 'multiple patches' do
+          skip
+        end
+
+        it 'only on the local node' do
+          skip
+        end
+
+        it 'only on a specified node' do
+          skip
+        end
+
+        it 'only on multiple specified nodes' do
+          skip 'Not implemented yet'
+        end
+      end
+
+      it 'installed on all nodes' do
+        skip
+      end
+
+      it 'detects a successful mark' do
+        skip
+      end
+    end
+
+    describe 'reinstall!' do
+      it 'single patch to all nodes by default' do
+        skip
+      end
+
+      it 'only multiple specified patches' do
+        skip
+      end
+
+      it 'only to the local node' do
+        skip
+      end
+
+      it 'only to a specified node' do
+        skip
+      end
+
+      it 'only to multiple specified nodes' do
+        skip 'Not implemented yet'
+      end
+
+      it 'without restarting the node' do
+        skip
+      end
+
+      it 'detects a successful reinstallation' do
+        skip
+      end
+
+      it 'detects a failed reinstallation' do
+        skip
+      end
+    end
+
+    describe 'revert!' do
+      it 'all patches on all nodes by default' do
+        skip
+      end
+
+      it 'only one patch' do
+        skip
+      end
+
+      it 'only multiple specified patches' do
+        skip
+      end
+
+      it 'only to the local node' do
+        skip
+      end
+
+      it 'only to a specified node' do
+        skip
+      end
+
+      it 'only to multiple specified nodes' do
+        skip 'Not implemented yet'
+      end
+
+      it 'without restarting the node' do
+        skip
+      end
+
+      it 'detects a successful revert' do
+        skip
+      end
+
+      it 'detects a failed revert' do
+        skip
+      end
+
+      it 'detects a patch this is unable to be reverted' do
+        skip 'Not implemented yet'
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: stackadmin
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andres Rojas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-23 00:00:00.000000000 Z
+dependencies:
+- !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: json
+  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: minitest
+  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: minitest-reporters
+  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: vagrant
+  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: vagrant-s3auth
+  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: rake
+  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: 
+email:
+- andres.rojas@mtnsat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/stackadmin.rb
+- lib/stackadmin/audit.rb
+- lib/stackadmin/base.rb
+- lib/stackadmin/exceptions.rb
+- lib/stackadmin/net-ssh.rb
+- lib/stackadmin/patch.rb
+- lib/stackadmin/version.rb
+- lib/stackadmin/yaml.rb
+- test/Vagrantfile
+- test/stackadmin_test.rb
+homepage: https://github.com/mtnsat/stackadmin
+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.0.14
+signing_key: 
+specification_version: 4
+summary: A helper class for administering Stackato deployments
+test_files:
+- test/Vagrantfile
+- test/stackadmin_test.rb