chloride 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6de9d1474d03d7012ae1831c35e9a9c572d5117f
-  data.tar.gz: 592bb951a691a867845ba875d918299cb397e5b7
+  metadata.gz: 4745a7cd2b20421818ebf6baf24deed96fca4f72
+  data.tar.gz: caf69fb1a91510985ac7cef32ec93304086ba7b6
 SHA512:
-  metadata.gz: 191910b3180eaa360b524e90800fac5586c07bb7b63f095ee24f030cc30fb8dbfc20403edcf4b83d52a0b5f6d0d9a0aab63570544b9ec8f5acc35c0c938543ab
-  data.tar.gz: a2fc72c58079d8829a36606be4612de5818c04efa1f22ca6b1446b758d8a95cb3f96b35df9859216b0e4ce9b153fc2d08fc877a7e6891d22d69c5d790e5fd858
+  metadata.gz: 39ca494f094616cbb357d7416e5751aaaa8452b6518187005fd81ac82264dcf74cf02918ae8a62c9a038cc58c9adbbcef8efd992b0ce2d1c42e4c735bbcaa3d5
+  data.tar.gz: ee6bc7998b0534ebd52f888e488d26c1d666d6bea4fa852a571581c4494008224bfef08870c027847b58016fe2c393ced62a5737e20f6b210901c472a2c15e05

data/.rubocop.yml

@@ -50,13 +50,18 @@ Lint/Void:
 
 # Offense count: 6
 Metrics/AbcSize:
+  Enabled: false
   Max: 70
 
 # Offense count: 4
 # Configuration parameters: CountComments.
 Metrics/BlockLength:
+  Enabled: false
   Max: 45
 
+Metrics/BlockNesting:
+  Max: 4
+
 # Offense count: 1
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
@@ -64,6 +69,7 @@ Metrics/ClassLength:
 
 # Offense count: 2
 Metrics/CyclomaticComplexity:
+  Enabled: false
   Max: 20
 
 # Offense count: 90
@@ -75,10 +81,12 @@ Metrics/LineLength:
 # Offense count: 10
 # Configuration parameters: CountComments.
 Metrics/MethodLength:
+  Enabled: false
   Max: 89
 
 # Offense count: 2
 Metrics/PerceivedComplexity:
+  Enabled: false
   Max: 23
 
 # Offense count: 10
@@ -119,6 +127,7 @@ Style/BracesAroundHashParameters:
 # Configuration parameters: EnforcedStyle, SupportedStyles.
 # SupportedStyles: nested, compact
 Style/ClassAndModuleChildren:
+  Enabled: false
   Exclude:
     - 'lib/chloride/action/execute.rb'
     - 'lib/chloride/action/file_copy.rb'
@@ -154,7 +163,10 @@ Style/Documentation:
     - 'lib/chloride/errors.rb'
     - 'lib/chloride/event.rb'
     - 'lib/chloride/event/message.rb'
+    - 'lib/chloride/executor.rb'
     - 'lib/chloride/host.rb'
+    - 'lib/chloride/step.rb'
+    - 'lib/chloride/step/noop.rb'
 
 # Cop supports --auto-correct.
 Style/EmptyLines:

data/lib/chloride/action/detect_platform.rb

@@ -0,0 +1,235 @@
+require 'chloride/errors'
+require 'chloride/action'
+
+# Executes a shell command on the hosts provided. Will block until completion.
+class Chloride::Action::DetectPlatform < Chloride::Action
+  attr_reader :results, :hosts
+
+  # TODO: Document args
+  def initialize(args)
+    super
+
+    @hosts = args[:hosts] || [args[:host]]
+  end
+
+  # TODO: Document block format
+  def go(&stream_block)
+    @status = :running
+    @results = Hash.new { |h, k| h[k] = {} }
+    @hosts.each do |host|
+      # First try identifying using lsb_release.  This takes care of Ubuntu (lsb-release is part of ubuntu-minimal).
+      lsb = exec_and_log(host, 'lsb_release -icr', true, @results[host.hostname], &stream_block)
+
+      if (lsb[:exit_status]).zero?
+        lsb_data = {}
+        lsb[:stdout].each_line do |l|
+          k, v = l.split(':')
+          lsb_data[k.strip] = v.strip if k && v
+        end
+
+        distribution = lsb_data['Distributor ID'].downcase.gsub(/\s+/, '')
+        distribution = case distribution
+                       when /redhatenterpriseserver|redhatenterpriseclient|redhatenterpriseas|redhatenterprisees|enterpriseenterpriseserver|redhatenterpriseworkstation|redhatenterprisecomputenode|oracleserver/
+                         :rhel
+                       when /enterprise.*/
+                         :centos
+                       when /scientific|scientifics|scientificsl/
+                         :rhel
+                       when /amazonami/
+                         :amazon
+                       when /suselinux/
+                         :sles
+                       else
+                         distribution.to_sym
+                       end
+
+        release = lsb_data['Release'].gsub(/\s+/, '')
+        release = case distribution
+                  when :centos, :rhel
+                    release.split('.')[0]
+                  when :debian
+                    if release == 'testing'
+                      '7'
+                    else
+                      release.split('.')[0]
+                    end
+                  else
+                    release
+                  end
+      end
+
+      # Check for Redhat
+      if !distribution && !release
+        redhat_release = exec_and_log(host, 'cat /etc/redhat-release', true, @results[host.hostname], &stream_block)
+
+        if (redhat_release[:exit_status]).zero?
+          stdout = redhat_release[:stdout]
+
+          distribution = case stdout
+                         when /red hat enterprise/im
+                           :rhel
+                         when /centos/im
+                           :centos
+                         when /scientific/im
+                           :rhel
+                         end
+
+          release = /.* release ([[:digit:]]).*/.match(stdout)[1]
+        end
+      end
+
+      # Check for Cumulus
+      if !distribution && !release
+        os_release = exec_and_log(host, 'cat /etc/os-release', true, @results[host.hostname], &stream_block)
+
+        if (os_release[:exit_status]).zero?
+          stdout = os_release[:stdout]
+
+          distribution = :cumulus if /Cumulus Linux/m =~ stdout
+          release = /VERSION_ID=(\d+\.\d)/.match(stdout)[1] if distribution
+        end
+      end
+
+      # Check for EOS
+      if !distribution && !release
+        eos_release = exec_and_log(host, 'cat /etc/Eos-release', true, @results[host.hostname], &stream_block)
+
+        if (eos_release[:exit_status]).zero?
+          stdout = eos_release[:stdout]
+
+          distribution = :eos if /Arista Networks EOS/m =~ stdout
+
+          release = /^Arista Networks EOS v*(.*)\..*$/.match(stdout)[1]
+        end
+      end
+
+      # Check for Debian
+      if !distribution && !release
+        debian_version = exec_and_log(host, 'cat /etc/debian_version', true, @results[host.hostname], &stream_block)
+
+        if (debian_version[:exit_status]).zero?
+          stdout = debian_version[:stdout]
+          distribution = :debian
+
+          release = case stdout
+                    when /^[[:digit:]]/
+                      stdout.split('.')[0]
+                    when /^wheezy/.match(stdout)
+                      '7'
+                    end
+        end
+      end
+
+      # Check for SuSE
+      if !distribution && !release
+        suse_release = exec_and_log(host, 'cat /etc/SuSE-release', true, @results[host.hostname], &stream_block)
+
+        if (suse_release[:exit_status]).zero?
+          stdout = suse_release[:stdout]
+
+          if /Enterprise Server/ =~ stdout
+            distribution = :sles
+            release = /^VERSION = (\d*)/m.match(stdout)[1]
+          end
+        end
+      end
+
+      # Check for Amazon 6, or fail
+      if !distribution && !release
+        system_release = exec_and_log(host, 'cat /etc/system-release', true, @results[host.hostname], &stream_block)
+
+        if (system_release[:exit_status]).zero?
+          stdout = system_release[:stdout]
+
+          if /amazon linux/im =~ stdout
+            distribution = :amazon
+            # How is this safe to assume?
+            release = '6'
+          end
+        end
+      end
+
+      # Check for Solaris
+      if !distribution && !release
+        uname = exec_and_log(host, 'uname -s', true, @results[host.hostname], &stream_block)
+
+        if (uname[:exit_status]).zero?
+          distribution = case uname.results[hostname][:stdout].strip
+                         when 'SunOS'
+                           unamer = exec_and_log(host, 'uname -r', true, @results[host.hostname], &stream_block)
+
+                           if (unamer[:exit_status]).zero?
+                             release = unamer.results[hostname][:stdout].split('.')[0]
+                           end
+
+                           :solaris
+                         when 'AIX'
+                           oslevel = exec_and_log(host, 'oslevel', true, @results[host.hostname], &stream_block)
+                           yield oslevel
+
+                           if (oslevel[:exit_status]).zero?
+                             release = oslevel.results[hostname][:stdout].split('.')[0..1].join('.')
+                           end
+
+                           :aix
+                         end
+        end
+      end
+
+      # Architecture
+      unamem = exec_and_log(host, 'uname -m', true, @results[host.hostname], &stream_block)
+
+      if (unamem[:exit_status]).zero?
+        architecture = unamem[:stdout].strip
+
+        architecture = case architecture
+                       when 'i686'
+                         'i386'
+                       when 'ppc'
+                         'powerpc'
+                       when 'x86_64'
+                         [:ubuntu, :debian].include?(distribution) ? 'amd64' : 'x86_64'
+                       else
+                         architecture
+                       end
+      end
+
+      host.data[:os] = {}
+      # Tag
+      @results[host.hostname][:distribution] = host.data[:os][:distribution] = distribution
+      @results[host.hostname][:release] = host.data[:os][:release] = release
+      @results[host.hostname][:architecture] = host.data[:os][:architecture] = architecture
+
+      tag_distribution = distribution || 'unknown'
+      tag_release = release || 'unknown'
+      tag_architecture = architecture || 'unknown'
+
+      @results[host.hostname][:tag] = host.data[:os][:tag] = case distribution
+                                                             when :rhel, :centos, :amazon
+                                                               "el-#{tag_release}-#{tag_architecture}"
+                                                             else
+                                                               "#{tag_distribution}-#{tag_release}-#{tag_architecture}"
+                                                             end
+    end
+
+    @results
+  end
+
+  def success?
+    @results.all? do |_host, result|
+      !(result[:distribution].nil? || result[:release].nil? || result[:architecture].nil?)
+    end
+  end
+
+  def error_message(hostname)
+    @results[hostname][:stderr].strip if @results.key?(hostname) && @results[hostname].key?(:stderr)
+  end
+
+  def name
+    :detect_platform
+  end
+
+  def description
+    "Detect OS on #{@hosts.join(', ')}"
+  end
+end

data/lib/chloride/event/message.rb

@@ -1,4 +1,4 @@
-require 'uri'
+require 'cgi'
 
 module Chloride
   class Event
@@ -15,7 +15,7 @@ module Chloride
         {
           severity: @severity,
           hostname: @hostname,
-          message: URI.escape(remove_ansi(@message))
+          message: CGI.escape_html(remove_ansi(@message))
         }.to_json(*args)
       end
 

data/lib/chloride/executor.rb

@@ -0,0 +1,67 @@
+class Chloride::Executor
+  def initialize(logger, &stream_block)
+    @logger = logger
+    @stream_block = stream_block
+  end
+
+  def publish(event, action_id = nil)
+    event.action_id = action_id if action_id
+    @stream_block.call(event) if @stream_block
+  end
+
+  def execute(steps)
+    # Perform the plan given
+    skip_remaining_steps = false
+
+    steps.each do |step|
+      # TODO: Check for step.pre
+      if skip_remaining_steps
+        publish Chloride::Event.new(:step_skip, step.name)
+        next
+      end
+
+      publish Chloride::Event.new(:step_start, step.name)
+
+      begin
+        step.perform_step do |action|
+          action_id = SecureRandom.uuid
+          publish(Chloride::Event.new(:action_start, action.name), action_id)
+
+          action.go do |event|
+            publish(event, action_id)
+          end
+
+          if action.success?
+            publish(Chloride::Event.new(:action_success, action.name), action_id)
+          else
+            publish(Chloride::Event.new(:action_fail, action.name), action_id)
+          end
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        # Treat *any* error like a step failure and proceed accordingly
+        @logger.error [e, *e.backtrace].join("\n")
+        step.error(step.infra.installer_hostname, "An error occured while performing #{step.name}: #{e.message}")
+      end
+
+      type = case step.status
+             when :error
+               skip_remaining_steps = step.fail_stop?
+               :step_error
+             when :warn
+               :step_warn
+             else
+               :step_success
+             end
+
+      Chloride::Event.new(type, step.name).tap do |event|
+        step.messages.each { |m| event.add_message(m) }
+        publish event
+      end
+
+      # Clear the messages so that revalidation doesn't log them again
+      step.reset
+
+      # TODO: Check for step.post
+    end
+  end
+end

data/lib/chloride/host.rb

@@ -7,7 +7,7 @@ require 'timeout'
 require 'json'
 
 class Chloride::Host
-  attr_reader :data, :remote_conn, :roles, :hostname, :username, :ssh_key_file, :ssh_key_passphrase, :alt_names, :localhost
+  attr_reader :data, :remote_conn, :hostname, :username, :ssh_key_file, :ssh_key_passphrase, :localhost
   attr_accessor :data
 
   def initialize(hostname, config = {})

data/lib/chloride/step.rb

@@ -0,0 +1,53 @@
+class Chloride::Step
+  attr_reader :actions, :hosts, :messages, :status
+
+  def initialize(data = {}, pre = nil, post = nil)
+    @pre = pre
+    @post = post
+    @data = data
+    @hosts = Set.new
+
+    @actions = []
+    @messages = []
+
+    @status = :success
+    @uuid = SecureRandom.uuid
+  end
+
+  def perform_step(_execute_block)
+    raise NotImplementedError, "Don't know how to perform this kind of step"
+  end
+
+  def name
+    raise NotImplementedError, 'Step name required'
+  end
+
+  def description
+    raise NotImplementedError, 'Step description required'
+  end
+
+  def fail_stop?
+    false
+  end
+
+  def reset
+    @status = :success
+    @messages.clear
+  end
+
+  def error(hostname, message)
+    @messages << Chloride::Event::Message.new(:error, hostname, message)
+    @status = :error
+  end
+
+  def warning(hostname, message)
+    @messages << Chloride::Event::Message.new(:warn, hostname, message)
+    @status = :warn unless @status == :error
+  end
+
+  def info(hostname, message)
+    @messages << Chloride::Event::Message.new(:info, hostname, message)
+  end
+end
+
+require 'chloride/event'

data/lib/chloride/step/noop.rb

@@ -0,0 +1,24 @@
+require 'chloride/step'
+
+class Chloride::Step::Noop < Chloride::Step
+  def initialize(data = {}, pre = nil, post = nil)
+    super(data, pre, post)
+    @name = data[:name]
+    @performed = false
+  end
+
+  def perform_step(_execute_block)
+    @performed = true
+    # noop
+  end
+
+  def performed?
+    @performed
+  end
+
+  attr_reader :name
+
+  def description
+    'Do basically nothing'
+  end
+end

data/lib/chloride/version.rb

@@ -1,3 +1,3 @@
 module Chloride
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chloride
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Brandon High
@@ -161,6 +161,7 @@ files:
 - chloride.gemspec
 - lib/chloride.rb
 - lib/chloride/action.rb
+- lib/chloride/action/detect_platform.rb
 - lib/chloride/action/execute.rb
 - lib/chloride/action/file_copy.rb
 - lib/chloride/action/mkdir.rb
@@ -169,7 +170,10 @@ files:
 - lib/chloride/errors.rb
 - lib/chloride/event.rb
 - lib/chloride/event/message.rb
+- lib/chloride/executor.rb
 - lib/chloride/host.rb
+- lib/chloride/step.rb
+- lib/chloride/step/noop.rb
 - lib/chloride/version.rb
 homepage: https://github.com/puppetlabs/chloride
 licenses: