loom-core 0.0.5 → 0.0.6

data/lib/loomext/coremods/git.rb

@@ -0,0 +1,19 @@
+module LoomExt::CoreMods
+  class Git < Loom::Mods::Module
+
+    register_mod :git
+    required_commands :git
+
+    module Actions
+      def push
+        shell.execute :git, :push
+      end
+
+      def pull
+        shell.execute :git, :pull
+      end
+    end
+  end
+
+  Git.import_actions Git::Actions
+end

data/lib/loomext/coremods/package/adapter.rb

@@ -40,7 +40,7 @@ module LoomExt::CoreMods
       end
 
       def install(pkg_name)
-        loom << "gem install #{pkg_name}"
+        loom.x :gem, :install, pkg_name
       end
     end
 

data/lib/loomext/coremods/systemd.rb

@@ -0,0 +1 @@
+require_relative "systemd/all"

data/lib/loomext/coremods/systemd/all.rb

@@ -0,0 +1,2 @@
+require_relative "systemd"
+require_relative "systemd_units"

data/lib/loomext/coremods/{system.rb → systemd/systemd.rb}

@@ -1,13 +1,27 @@
 module LoomExt::CoreMods
 
+  module SystemdCommon
+    def do_systemctl(action, unit=nil, *args, flags: [])
+      flags << "--no-pager"
+      flags << "--no-legend"
+      flags << "--no-ask-password"
+
+      exec_args = [
+        "systemctl",
+        flags,
+        action,
+        unit
+      ].flatten.compact
+      args = exec_args.concat args
+      shell.execute(*args)
+    end
+  end
+
   class Systemd < Loom::Mods::Module
+    include SystemdCommon
 
     register_mod :systemd
 
-    def do_systemctl(action, *args)
-      shell.execute "systemctl", action, *args
-    end
-
     module Actions
 
       def is_loaded?(unit)
@@ -15,7 +29,7 @@ module LoomExt::CoreMods
       end
 
       def is_active?(unit)
-        status(unit).match? /^\s+Active:\sactive\s/
+        do_systemctl "is-active", unit
       end
 
       def status(unit)

data/lib/loomext/coremods/systemd/systemd_units.rb

@@ -0,0 +1,69 @@
+module LoomExt::CoreMods
+
+  module SystemdUnitsCommon
+
+    def init_action(*units, type: nil)
+      @units = units
+      @type = type
+    end
+
+    def do_systemctl_list(list_what, flags=common_list_flags)
+      do_systemctl("list-%s" % list_what, flags: flags)
+    end
+
+    def common_list_flags
+      ["--plain", "--full", "--all"]
+    end
+  end
+
+  class SystemdUnits < Loom::Mods::Module
+    include SystemdCommon
+    include SystemdUnitsCommon
+
+    register_mod :systemd_units
+
+    module Actions
+      def list
+        do_systemctl_list :units
+      end
+
+      def status
+        @units.map do |unit|
+          do_systemctl "status", unit, flags: ["--output=short-unix"]
+        end
+      end
+    end
+
+    import_actions Actions
+  end
+
+  class SystemdSockets < SystemdUnits
+    include SystemdCommon
+    include SystemdUnitsCommon
+
+    register_mod :systemd_sockets
+
+    module Actions
+      def list
+        do_systemctl_list :sockets
+      end
+    end
+
+    import_actions Actions
+  end
+
+  class SystemdTimers < SystemdUnits
+    include SystemdCommon
+    include SystemdUnitsCommon
+
+    register_mod :systemd_timers
+
+    module Actions
+      def list
+        do_systemctl_list :timers
+      end
+    end
+
+    import_actions Actions
+  end
+end

data/scripts/harness.sh

@@ -7,6 +7,7 @@
 #
 # 1. base64 encode an arbitrary shell script, this is the encoded
 #    script
+# TODO[P0]: this should be a checksum for the original script!!! Check the code.
 # 2. get a checksum for the encoded script
 # 3. send the encoded script and checksum to a shell in another
 #    process (local or remote) to invoke the encoded script via this

data/spec/.loom/error_handling.loom

@@ -0,0 +1,15 @@
+# !!! NOTE: This will reboot the host it runs on!!!
+module ErrorHandling
+  include Loom::Pattern
+
+  namespace :err
+
+  desc "Handle SSH disconnection errors"
+  pattern :ssh_disconnect do |loom, facts|
+    if facts[:really_really_reboot]
+      loom.sudo cmd: :reboot
+    else
+      puts "to REALLY reboot set fact[:really_really_reboot] = true"
+    end
+  end
+end

data/spec/.loom/fail.loom

@@ -0,0 +1,20 @@
+# All patterns are expected to fail
+
+desc "Always fails due to return code."
+pattern :fail_soft do |loom, facts|
+  unless loom << :false
+    loom.x :echo, "i am false"
+  end
+end
+
+desc "Always fails due to a hard failure"
+pattern :fail_hard do |loom, facts|
+  loom.fail "Fail big or not at all"
+end
+
+desc "Expected to fail: Check timeout commands"
+pattern :timeout_fail do |loom, facts|
+  loom.timeout(:timeout => 1) do
+    loom.x :sleep, 2
+  end
+end

data/spec/.loom/files.loom

@@ -0,0 +1,39 @@
+# Tests for LoomExt::CoreMods::Package
+module Files
+  include Loom::Pattern
+
+  desc "Reads a file"
+  pattern :read do |loom, facts|
+    loom.files("/etc/hosts").cat
+  end
+
+  desc "Gsubs file text"
+  pattern :gsub do |loom, facts|
+    loom.files("/tmp/garbage").write <<EOS
+This is a bunch of junk
+192.123.456.0\t\thostname.xyz
+EOS
+
+    loom.files("/tmp/garbage")
+      .cat
+      .gsub(pattern: /[\d]{3}/, replace: "xxx")
+      .append("this is something new")
+      .cat
+  end
+
+  desc "Chowns a file"
+  pattern :chown do |loom, facts|
+    loom.files("/tmp/chown.me")
+      .touch
+      .append("this file will be owned by root")
+
+    loom.sudo do
+      loom.files("/tmp/chown.me").chown user: :root
+      loom.x :ls, "-lZ", "/tmp/chown.me"
+
+      loom.files("/tmp/chown.me").chown user: :root, group: :root
+    end
+
+    loom.sudo { loom.exec :rm, "/tmp/chown.me" }
+  end
+end

data/spec/.loom/net.loom

@@ -0,0 +1,21 @@
+module Net
+  include Loom::Pattern
+
+  desc "tests the net package, with_net check"
+  pattern :check_net do |loom, facts|
+    unless loom.net(check_host: '127.0.0.1').has_net?
+      loom.fail 'can not ping localhost'
+    end
+
+    has_local_net = false
+    loom.net(check_host: '127.0.0.1').with_net do
+      has_local_net = true
+    end
+    loom.fail "should have local net" unless has_local_net
+  end
+
+  desc "expected check_net failures"
+  pattern :check_net_fail do |loom, facts|
+    loom.net(timeout: 2, check_host: '1.1.1.1').check_net
+  end
+end

data/spec/.loom/pattern_context.loom

@@ -0,0 +1,78 @@
+# Tests patterns nested at deeper module levels with contextual let, before, and
+# after hooks. Verifies hook order and contexts are set correctly.
+module PatternContext
+  module Parent
+    include Loom::Pattern
+
+    with_facts :outer_fact => :outer, :replaced => :original
+
+    before do
+      puts "Test::Parent => before"
+    end
+
+    after do
+      puts "Test::Parent => after"
+    end
+
+    desc "Checks facts on a parent pattern"
+    pattern :check_facts do |loom, facts|
+      unless facts[:outer_fact] == :outer
+        raise "expected outer fact => #{facts[:outer_fact]}"
+      end
+    end
+
+    let(:a_let_key) { "the value" }
+    let(:a_fact_based_let) { |facts| facts[:outer_fact].to_s + "/let" }
+    let(:a_referencing_let) { a_let_key + " referenced" }
+
+    desc "Checks let defines"
+    pattern :check_lets do |loom, facts|
+      raise "bad let :a_let_key" unless a_let_key == "the value"
+      raise "bad let :a_fact_based_let" unless a_fact_based_let == "outer/let"
+
+      unless a_referencing_let == "the value referenced"
+        raise "bad let :a_referencing_let => #{a_referencing_let}"
+      end
+
+      puts "a_let_key: %s" % a_let_key
+      puts "a_fact_based_let: %s" % a_fact_based_let
+    end
+
+    module Child
+      include Loom::Pattern
+
+      with_facts :inner_fact => :inner, :replaced => :override
+      let(:a_let_key) { |facts|  facts[:inner_fact].to_s + " overrides parent" }
+
+      before do
+        puts "Test::Parent::Child => before"
+      end
+
+      after do
+        puts "Test::Parent::Child => after"
+      end
+
+      desc "Check let overrides"
+      pattern :check_let_overrides do |loom, facts|
+        raise "bad let :a_let_key" unless a_let_key == "inner overrides parent"
+        raise "bad let :a_fact_based_let" unless a_fact_based_let == "outer/let"
+
+        puts "child a_let_key: %s" % a_let_key
+        puts "child a_fact_based_let: %s" % a_fact_based_let
+      end
+
+      desc "Checks inherited facts on a cihld pattern"
+      pattern :check_facts do |loom, facts|
+        unless facts[:inner_fact] == :inner
+          raise "expected inner fact => #{facts[:inner_fact]}"
+        end
+        unless facts[:outer_fact] == :outer
+          raise "expected outer fact => #{facts[:outer_fact]}"
+        end
+        unless facts[:replaced] == :override
+          raise "expected replaced fact => #{facts[:replaced_fact]}"
+        end
+      end
+    end # Child
+  end # Parent
+end #PatternContext

data/spec/.loom/pkg.loom

@@ -0,0 +1,33 @@
+# Tests for LoomExt::CoreMods::Package
+module Package
+  include Loom::Pattern
+
+  namespace :pkg
+
+  before do |loom, facts|
+    puts "#{self} in before"
+  end
+
+  after do
+    puts "#{self} in after"
+  end
+
+  desc "Updates the default package manager cache"
+  pattern :update_cache do |loom, facts|
+    loom.sudo { loom.pkg.update_cache }
+  end
+
+  desc "Installs Apache HTTP server"
+  pattern :install_httpd do |loom, facts|
+    loom.sudo do
+      loom.pkg.install 'apache2' unless loom.pkg.installed? 'apache2'
+    end
+  end
+
+  desc "Installs Facter GEM"
+  pattern :install_facter do |loom, facts|
+    loom.sudo do
+      loom.pkg[:gem].ensure_installed :facter
+    end
+  end
+end

data/spec/.loom/shell.loom

@@ -0,0 +1,46 @@
+module Shell
+  include Loom::Pattern
+
+  desc "Executes some commands in a subshell"
+  pattern :subshell do |loom, facts|
+    loom << :"(echo $$; echo $BASHPID; whoami)"
+    loom << :"(sudo -i -u root whoami)"
+
+    loom.local << :"(echo $$; echo $BASHPID; whoami)"
+    #    loom.local << "(sudo -i -u root whoami)"
+  end
+
+  desc "Tests nested sudo scenarios"
+  pattern :sudo do |loom, facts|
+    loom.sudo user: "root" do
+      loom << :pwd
+      loom << :whoami
+      loom.exec :touch, "loom.file"
+
+      loom.sudo do
+        loom << :whoami
+        loom << :pwd
+        loom.x :touch, "root.file"
+
+        loom.user.add_system_user :postgres, uid: 999
+        loom.sudo user: :postgres do
+          loom << :whoami
+          loom.cd "/tmp" do
+            loom << :pwd
+            loom.x :touch, "postgres.file"
+          end
+        end
+        loom.user.remove :postgres
+
+        loom.x :touch, "root.file2"
+      end
+    end
+
+    loom.cd "/tmp" do
+      loom << :pwd
+      loom.sudo user: :root, cmd: :pwd do loom << :pwd end
+      loom << :pwd
+    end
+
+  end
+end

data/spec/.loom/test.loom

@@ -0,0 +1,73 @@
+# TODO: add in test verifications that these tests are actually doing what
+# they're supposed to do.
+
+module Smoke
+  include Loom::Pattern
+
+  desc "Prints some known facts"
+  report :three_facts do |loom, facts|
+    facts
+  end
+
+  desc "Reports `uptime` status"
+  pattern :uptime do |loom, facts|
+    loom << :uptime
+    loom << :hostname
+    loom.local << :hostname
+  end
+  #produces { pkg.installed? :httpd }
+
+  desc "cd's to the /etc directory and runs `pwd`"
+  pattern :cd do |loom, facts|
+    loom.cd "/etc" do
+      loom << :pwd
+    end
+  end
+
+  desc "tests return codes from wrapped commands"
+  pattern :wrap_returns do |loom, facts|
+    # using loom.time as a proxy for Shell::Core#wrap here
+    loom.time do
+      raise "wrapped true is not true" unless loom.test :true
+      raise "wrapped false is not false" if loom.test :false
+    end
+  end
+
+  desc "Tests a condition."
+  pattern :test do |loom, facts|
+    unless loom.test :false
+      loom.x :echo, "i tested false"
+    end
+
+    if loom.test :true
+      loom.x :echo, "i tested true"
+    end
+
+    if loom.test :which, "bash"
+      loom.x :echo, "has bash"
+    end
+  end
+
+  desc "Tests a grep condition."
+  pattern :match do |loom, facts|
+    if loom.files("/etc/hosts").match? :pattern => "aldsfja;ldjf"
+      loom.fail "should not match garbage"
+    else
+      loom.x :echo, "I didnt match garbage"
+    end
+
+    unless loom.files("/etc/hosts").match? :pattern => "localhost"
+      loom.fail "should match localhost"
+    else
+      loom.x :echo, "I did match my target"
+    end
+  end
+end
+
+desc "Wrapped time commands"
+pattern :time do |loom, facts|
+  loom.time do
+    loom.x :echo, :hi
+    loom.x :sleep, 2
+  end
+end