loom-core 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '00595d8a3c27f3c3a2567849e6d188c68a3c5914646238f0009767bff5769687'
+  data.tar.gz: 1988e1d88027c87309183db5355a2167f46ef2c48efcde7d5d143daf04011ea3
+SHA512:
+  metadata.gz: a48f5d6d82ec87da2c8e0dca0107602a434f8e4d8f42e1eb5d4d5638106aea1733836745d91db52f497b0eb4d2b9812909a42e9aef10a6408a26b23cb227758c
+  data.tar.gz: dc23a63efd9405c7834911e66a709f944793e8b9bca62858e0a86864f999d0d8e942a21f9bda9893bd2672291806205d0b7e752cb9dbe70e0b2854630434bb97

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,99 @@
+PATH
+  remote: .
+  specs:
+    loom-core (0.0.1)
+      bcrypt_pbkdf (= 1.0.0.alpha1)
+      commander (~> 4.4)
+      net-ssh (>= 3)
+      rbnacl-libsodium (= 1.0.10)
+      sshkit (~> 1.11)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bcrypt_pbkdf (1.0.0.alpha1)
+    byebug (9.0.6)
+    coderay (1.1.1)
+    commander (4.4.0)
+      highline (~> 1.7.2)
+    diff-lcs (1.2.5)
+    ffi (1.9.14)
+    formatador (0.2.5)
+    guard (2.14.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    highline (1.7.8)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.10)
+    method_source (0.8.2)
+    nenv (0.3.0)
+    net-scp (1.2.1)
+      net-ssh (>= 2.6.5)
+    net-ssh (3.2.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.4.0)
+      byebug (~> 9.0)
+      pry (~> 0.10)
+    rake (11.3.0)
+    rb-fsevent (0.9.8)
+    rb-inotify (0.9.7)
+      ffi (>= 0.5.0)
+    rbnacl (3.4.0)
+      ffi
+    rbnacl-libsodium (1.0.10)
+      rbnacl (>= 3.0.1)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    ruby_dep (1.5.0)
+    shellany (0.0.1)
+    slop (3.6.0)
+    sshkit (1.11.4)
+      net-scp (>= 1.1.2)
+      net-ssh (>= 2.8.0)
+    thor (0.19.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.13)
+  guard-rspec (~> 4.7)
+  loom-core!
+  pry (~> 0.10)
+  pry-byebug
+  rake (~> 11.3)
+  rspec (~> 3.5)
+
+BUNDLED WITH
+   1.13.6

data/Guardfile

@@ -0,0 +1,54 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Explicitly speficy emacs in order to disable notify-send notifications
+  notification :emacs
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Loom shell scripts
+  watch(%r{^scripts/(.+)\.sh$}) { |m| "spec/scripts/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/loom

@@ -0,0 +1,185 @@
+#!/usr/bin/env ruby
+if __FILE__ == $0
+  # for local development, when running bin/loom directly
+  $: << 'lib'
+end
+
+require 'commander'
+require 'loom'
+
+Loom.configure do |c|
+  c.log_level = :info
+end
+
+module Loom
+  class Cli
+    include Commander::Methods
+
+    def run
+      program :name, "Loom - Weaving through infrastructure"
+      program :version , Loom::VERSION
+      program :description, <<EOS
+A lightweight infrastructure managment tool designed to manage hosts
+through SSH, loosely inspired by Python Fabric - http://www.fabfile.org/.
+
+Try `loom weave uptime -H localhost` to see an example.
+EOS
+
+      global_option "-V", "--verbose", "Report verbose results" do |v|
+        Loom.configure do |c|
+          c.run_verbose = v
+        end
+      end
+
+      global_option "-d", "Enable loom debug logging, implies --verbose" do |d|
+        Loom.configure do |c|
+          c.log_level = :debug
+          c.run_verbose = true
+        end
+      end
+
+      global_option "--dbg [N]", Integer,
+                    "Enable deep debug logging, where N is 0-6, implies --verbose" do |n|
+        raise "N must be greater than 0" if n < 0
+        Loom.configure do |c|
+          c.log_level = n * -1
+          c.run_verbose = true
+        end
+      end
+
+      global_option "-l", "--loom-files file1,f2,f3", Array,
+                    "Load loom files from FILES instead of from the search path." do |files|
+        Loom.configure { |c| c.loom_files = files }
+      end
+
+      global_option "-a", "--all-hosts",
+                    "Adds all known hostnames to the active inventory, " +
+                    "can be combined with -H for additional hosts" do |flag|
+        Loom.configure { |c| c.inventory_all_hosts = flag }
+      end
+
+      global_option "-H", "--hosts host1,h2,h3", Array,
+                    "Adds HOSTS to the active inventory" do |hosts|
+        Loom.configure { |c| c.inventory_hosts = hosts }
+      end
+
+      global_option "-G", "--groups group1,g2,g3", Array,
+                    "Adds hostnames in GROUPS to the active inventory" do |groups|
+        Loom.configure { |c| c.inventory_groups = groups }
+      end
+
+      global_option "-X", "--custom-config KEY=VAL", String do |config_value|
+        key, val, *_rest = config_value.split "="
+        Loom.configure do |c|
+          c[key.to_sym] = val
+        end
+      end
+
+      default_command :weave
+
+      command :"weave" do |c|
+        c.syntax = "loom weave [pattern...] [options]"
+        c.description = "Applies the patterns to the active host inventory. " +
+                        "This is the default."
+
+        c.option "-A", "--all",
+                 "Run all loaded the patterns"
+        c.option "-n", "--dry-run",
+                 "Don't run the patterns, only connect and log the expected patterns"
+        c.option "-F", "--fact F1=V1[,F2=V2,F3=V3]]]", "add custom fact"
+
+        c.action do |patterns, options|
+          if options.all
+            patterns = Loom::Pattern::Loader.load(Loom.config).slugs
+          end
+
+          other_facts = {}
+          if options.fact
+            fact_pairs = options.fact.split ","
+            fact_pairs.each do |pair|
+              key, val = pair.split "="
+              other_facts[key.to_sym] = val
+            end
+          end
+
+          runner = Loom::Runner.new Loom.config, patterns, other_facts
+          runner.run options.dry_run
+        end
+      end
+      alias_command :"w", :"weave"
+
+      command :"mods" do |c|
+        c.syntax = "loom mods [mod]"
+        c.description = "Prints the list of registered mods."
+
+        c.action do |mods, options|
+          puts "Loom mods are:"
+          puts ""
+
+          Loom::Mods::ModLoader.registered_mods.each do |name, aliases|
+            puts aliases.join(", ")
+            puts "\t#{name}"
+          end
+        end
+      end
+
+      command :"patterns" do |c|
+        c.syntax = "loom patterns [pattern]"
+        c.description = "Prints the list of known patterns."
+
+        c.option "--print", "Only print the space separted pattern names."
+        c.action do |patterns, options|
+          pattern_loader = Loom::Pattern::Loader.load Loom.config
+          pattern_slugs = pattern_loader.slugs
+          if options.print
+            puts pattern_slugs.join " "
+            return
+          end
+
+          puts "Loom patterns are:"
+          puts ""
+
+          max_slug_len = pattern_slugs.map(&:size).reduce(0) { |*args| args.max }
+          pattern_loader.patterns.each do |ref|
+            puts "\t#{ref.slug.ljust(max_slug_len)}\t#{ref.desc}"
+          end
+        end
+      end
+      alias_command :"p", :"patterns"
+
+      command :"config" do |c|
+        c.syntax = "loom config [options]"
+        c.description = "Print the config."
+        c.action do
+          puts Loom.config.to_yaml
+        end
+      end
+      alias_command :"c", :"config"
+
+      command :"inventory" do |c|
+        c.syntax = "loom inventory [options]"
+        c.description = "List all hosts in the inventory."
+
+        c.option "--active", <<EOS
+Restricts to the hosts in the active inventory, useful to check which
+hosts will be targeted with the config. Using with the -a flag is
+equivalent to omitting --active.
+EOS
+
+        c.action do |arg, options|
+          inventory = if options.active
+                        Loom::Inventory::InventoryList.active_inventory Loom.config
+                      else
+                        Loom::Inventory::InventoryList.total_inventory Loom.config
+                      end
+          puts inventory.hostnames.sort.to_yaml
+        end
+      end
+      alias_command :"i", :"inventory"
+
+      run!
+    end
+  end
+end
+
+Loom::Cli.new.run

data/lib/env/development.rb

@@ -0,0 +1 @@
+require 'pry'

data/lib/loom.rb

@@ -0,0 +1,44 @@
+require 'env/development'
+
+module Loom
+
+  LoomError = Class.new ::StandardError
+  ExecutionError = Class.new LoomError
+
+  class << self
+    def configure(&block)
+      @config = Loom::Config.configure @config, &block
+      config_changed
+    end
+
+    def config
+      unless @config
+        @config = Loom::Config.configure
+        config_changed
+      end
+      @config
+    end
+
+    def reset_config
+      @config = nil
+    end
+
+    def log
+      @logger ||= config_logger
+    end
+
+    private
+    def config_changed
+      SSHKit.config.output_verbosity = config.sshkit_log_level
+      SSHKit.config.default_runner = config.sshkit_execution_strategy
+      @logger = nil
+    end
+
+    def config_logger
+      @logger = Loom::Logger.configure config
+    end
+
+  end
+end
+
+require 'loom/all'

data/lib/loom/all.rb

@@ -0,0 +1,20 @@
+require "sshkit"
+
+require_relative "core_ext"
+require_relative "method_signature"
+require_relative "trap"
+
+require_relative "logger"
+require_relative "config"
+
+require_relative "shell"
+require_relative "host_spec"
+require_relative "dsl"
+
+require_relative "inventory"
+require_relative "facts"
+require_relative "pattern"
+require_relative "mods"
+require_relative "runner"
+
+require_relative "version"

data/lib/loom/config.rb

@@ -0,0 +1,106 @@
+require 'ostruct'
+require 'yaml'
+
+module Loom
+
+  ConfigError = Class.new Loom::LoomError
+
+  class Config
+
+    CONFIG_VARS = {
+      :loom_search_paths => ['/etc/loom', File.join(ENV['HOME'], '.loom'), './.loom'],
+      :loom_files => ['site.loom'],
+
+      :inventory_all_hosts => false,
+      :inventory_hosts => [],
+      :inventory_groups => [],
+
+      :log_level => :warn, # [debug, info, warn, error, fatal, or Integer]
+      :log_device => :stderr, # [stderr, stdout, file descriptor, or file name]
+      :log_colorize => true,
+
+      :run_failure_strategy => :exclude_host, # [exclude_host, fail_fast, cowboy]
+      :run_verbose => false,
+
+      :sshkit_execution_strategy => :sequence, # [sequence, parallel, groups]
+      :sshkit_log_level => :warn,
+    }.freeze
+
+    attr_reader *CONFIG_VARS.keys, :config_map
+
+    def initialize(**config_map)
+      config_map.each do |k,v|
+        # allows attr_reader methods from CONFIG_VAR to work
+        instance_variable_set :"@#{k}", v
+      end
+
+      @config_map = config_map
+      @file_manager = FileManager.new self
+    end
+
+    def [](key)
+      @config_map[key]
+    end
+
+    def to_yaml
+      @config_map.to_yaml
+    end
+    alias_method :dump, :to_yaml # aliased to dump for debugging purposes
+
+    def files
+      @file_manager
+    end
+
+    class << self
+      def configure(config=nil, &block)
+        # do NOT call Loom.log inside this block, the logger may not be
+        # configured, triggering an infinite recursion
+
+        map = config ? config.config_map : CONFIG_VARS.dup
+        config_struct = OpenStruct.new **map
+        yield config_struct if block_given?
+        Config.new config_struct.to_h
+      end
+    end
+
+    private
+    class FileManager
+
+      LOOM_FILE_PATTERNS = ["*.loom"]
+
+      def initialize(config)
+        @loom_search_paths = config.loom_search_paths
+        @loom_files = config.loom_files
+      end
+
+      def find(glob_patterns)
+        search_loom_paths(glob_patterns)
+      end
+
+      def loom_files
+        [@loom_files + search_loom_paths(LOOM_FILE_PATTERNS)].flatten.uniq
+      end
+
+      private
+      def search_loom_paths(file_patterns)
+        # Maps glob patterns into real file paths, selecting only
+        # readable files, and logs the result.
+        file_patterns.map do |file_pattern|
+          @loom_search_paths.map do |path|
+            Dir.glob File.join(path, "**", file_pattern)
+          end
+        end.flatten.uniq.select do |path|
+          should_select = File.file?(path) && File.readable?(path)
+          unless should_select
+            Loom.log.debug1(self) { "skipping config path => #{path}" }
+          end
+          should_select
+        end.tap do |config_files|
+          unless config_files.empty?
+            Loom.log.debug1(self) { "found config files => #{config_files}" }
+          end
+        end.uniq
+      end
+    end
+  end
+end