chake 0.19 → 0.80

data/lib/chake/config.rb

@@ -0,0 +1,16 @@
+require 'chake/node'
+
+module Chake
+  class << self
+    attr_accessor :nodes
+  end
+end
+
+nodes_file = ENV['CHAKE_NODES'] || 'nodes.yaml'
+nodes_directory = ENV['CHAKE_NODES_D'] || 'nodes.d'
+node_data = File.exist?(nodes_file) && YAML.load_file(nodes_file) || {}
+Dir.glob(File.join(nodes_directory, '*.yaml')).sort.each do |f|
+  node_data.merge!(YAML.load_file(f))
+end
+
+Chake.nodes = node_data.map { |node, data| Chake::Node.new(node, data) }.reject(&:skip?).uniq(&:hostname)

data/lib/chake/config_manager.rb

@@ -0,0 +1,93 @@
+require 'pathname'
+
+module Chake
+  class ConfigManager
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def converge; end
+
+    def apply(config); end
+
+    def path
+      "/var/tmp/#{name}.#{node.username}"
+    end
+
+    def name
+      self.class.short_name
+    end
+
+    def to_s
+      name
+    end
+
+    def bootstrap_steps
+      base = File.join(File.absolute_path(File.dirname(__FILE__)), 'bootstrap')
+      steps = Dir[File.join(base, '*.sh')] + Dir[File.join(base, name, '*.sh')]
+      steps.sort_by { |f| File.basename(f) }
+    end
+
+    def needs_bootstrap?
+      true
+    end
+
+    def needs_upload?
+      true
+    end
+
+    def self.short_name
+      name.split('::').last.downcase
+    end
+
+    def self.priority(new_prioriry = nil)
+      @priority ||= new_prioriry || 50
+    end
+
+    def self.inherited(klass)
+      super
+      @subclasses ||= []
+      @subclasses << klass
+    end
+
+    def self.get(node)
+      available = @subclasses.sort_by(&:priority)
+      manager = available.find { |c| c.short_name == node.data['config_manager'] }
+      manager ||= available.find { |c| c.accept?(node) }
+      raise ArgumentError, "Can't find configuration manager class for node #{node.hostname}. Available: #{available}.join(', ')}" unless manager
+
+      manager.new(node)
+    end
+
+    def self.accept?(_node)
+      false
+    end
+
+    def self.all
+      @subclasses
+    end
+
+    def self.init
+      skel = Pathname(__FILE__).parent / 'config_manager' / 'skel' / short_name
+      skel.glob('**/*').each do |source|
+        target = source.relative_path_from(skel)
+        if target.exist?
+          puts "exists: #{target}"
+        else
+          if source.directory?
+            FileUtils.mkdir_p target
+          else
+            FileUtils.cp source, target
+          end
+          puts "create: #{target}"
+        end
+      end
+    end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/config_manager/*.rb"].sort.each do |f|
+  require f
+end

data/lib/chake/config_manager/chef.rb

@@ -0,0 +1,35 @@
+require 'chake/config'
+require 'chake/tmpdir'
+
+module Chake
+  class ConfigManager
+    class Chef < ConfigManager
+      CONFIG = ENV['CHAKE_CHEF_CONFIG'] || 'config.rb'
+
+      def converge
+        node.run_as_root "sh -c 'rm -f #{node.path}/nodes/*.json && chef-solo -c #{node.path}/#{CONFIG} #{logging} -j #{json_config}'"
+      end
+
+      def apply(config)
+        node.run_as_root "sh -c 'rm -f #{node.path}/nodes/*.json && chef-solo -c #{node.path}/#{CONFIG} #{logging} -j #{json_config} --override-runlist recipe[#{config}]'"
+      end
+
+      priority 99
+
+      def self.accept?(_node)
+        true # this is the default, but after everything else
+      end
+
+      private
+
+      def json_config
+        parts = [node.path, Chake.tmpdir, "#{node.hostname}.json"].compact
+        File.join(parts)
+      end
+
+      def logging
+        node.silent && '-l fatal' || ''
+      end
+    end
+  end
+end

data/lib/chake/config_manager/itamae.rb

@@ -0,0 +1,58 @@
+require 'shellwords'
+require 'chake/config'
+require 'chake/tmpdir'
+
+module Chake
+  class ConfigManager
+    class Itamae < ConfigManager
+      def converge
+        run_itamae(*node.data['itamae'])
+      end
+
+      def apply(config)
+        run_itamae(config)
+      end
+
+      def needs_bootstrap?
+        false
+      end
+
+      def needs_upload?
+        false
+      end
+
+      def self.accept?(node)
+        node.data.key?('itamae')
+      end
+
+      private
+
+      def run_itamae(*recipes)
+        cmd = ['itamae']
+        case node.connection
+        when Chake::Connection::Ssh
+          cmd << 'ssh' << "--user=#{node.username}" << "--host=#{node.hostname}"
+          cmd += ssh_config
+        when Chake::Connection::Local
+          cmd << 'local'
+        else
+          raise NotImplementedError, "Connection type #{node.connection.class} not supported for itamee"
+        end
+        cmd << "--node-json=#{json_config}"
+        cmd += recipes
+        node.log("$ #{cmd.join(' ')}")
+        io = IO.popen(cmd, 'r', err: %i[child out])
+        node.connection.read_output(io)
+      end
+
+      def json_config
+        File.join(Chake.tmpdir, "#{node.hostname}.json")
+      end
+
+      def ssh_config
+        ssh_config = node.connection.send(:ssh_config_file) # FIXME
+        File.exist?(ssh_config) ? ["--ssh-config=#{ssh_config}"] : []
+      end
+    end
+  end
+end

data/lib/chake/config_manager/shell.rb

@@ -0,0 +1,34 @@
+require 'shellwords'
+require 'chake/config'
+
+module Chake
+  class ConfigManager
+    class Shell < ConfigManager
+      def converge
+        commands = node.data['shell'].join(' && ')
+        node.run_as_root sh(commands)
+      end
+
+      def apply(config)
+        node.run_as_root sh(config)
+      end
+
+      def self.accept?(node)
+        node.data.key?('shell')
+      end
+
+      private
+
+      def sh(command)
+        if node.path
+          command = "cd #{node.path} && " + command
+        end
+        if node.silent
+          "sh -ec '#{command}' >/dev/null"
+        else
+          "sh -xec '#{command}'"
+        end
+      end
+    end
+  end
+end

data/lib/chake/config_manager/skel/chef/Rakefile

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

data/lib/chake/config_manager/skel/chef/config.rb

@@ -0,0 +1,4 @@
+root = __dir__
+file_cache_path   "#{root}/cache"
+cookbook_path     "#{root}/cookbooks"
+role_path         "#{root}/config/roles"

data/lib/chake/config_manager/skel/chef/cookbooks/basics/recipes/default.rb

@@ -0,0 +1 @@
+package 'openssh-server'

data/lib/chake/config_manager/skel/chef/nodes.yaml

@@ -0,0 +1,3 @@
+host1.mycompany.com:
+  run_list:
+    - recipe[basics]

data/lib/chake/config_manager/skel/itamae/Rakefile

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

data/lib/chake/config_manager/skel/itamae/cookbooks/basics/default.rb

@@ -0,0 +1 @@
+package 'openssh-server'

data/lib/chake/config_manager/skel/itamae/nodes.yaml

@@ -0,0 +1,3 @@
+host1.mycompany.com:
+  itamae:
+    - roles/basic.rb

data/lib/chake/config_manager/skel/itamae/roles/basic.rb

@@ -0,0 +1 @@
+include_recipe '../cookbooks/basics'

data/lib/chake/config_manager/skel/shell/Rakefile

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

data/lib/chake/config_manager/skel/shell/nodes.yaml

@@ -0,0 +1,3 @@
+host1.mycompany.com:
+  shell:
+    - echo "HELLO WORLD"

data/lib/chake/connection.rb

@@ -0,0 +1,83 @@
+module Chake
+  Connection = Struct.new(:node) do
+    class CommandFailed < RuntimeError
+    end
+
+    def scp
+      ['scp']
+    end
+
+    def scp_dest
+      ''
+    end
+
+    def rsync
+      ['rsync']
+    end
+
+    def rsync_dest
+      "#{node.path}/"
+    end
+
+    def run(cmd)
+      node.log('$ %<command>s' % { command: cmd })
+      io = IO.popen(command_runner + ['/bin/sh'], 'w+', err: %i[child out])
+      io.write(cmd)
+      io.close_write
+      read_output(io)
+    end
+
+    def read_output(io)
+      io.each_line do |line|
+        node.log(line.gsub(/\s*$/, ''))
+      end
+      io.close
+      if $CHILD_STATUS
+        status = $CHILD_STATUS.exitstatus
+        if status != 0
+          raise CommandFailed, [node.hostname, 'FAILED with exit status %<status>d' % { status: status }].join(': ')
+        end
+      end
+    end
+
+    def run_shell
+      system(*shell_command)
+    end
+
+    def run_as_root(cmd)
+      if node.remote_username == 'root'
+        run(cmd)
+      else
+        run("sudo #{cmd}")
+      end
+    end
+
+    def to_s
+      self.class.connection_name
+    end
+
+    def skip?
+      false
+    end
+
+    def self.connection_name
+      name.split('::').last.downcase
+    end
+
+    def self.inherited(subclass)
+      super
+      @connections ||= []
+      @connections << subclass
+    end
+
+    def self.get(name)
+      connection = @connections.find { |b| b.connection_name == name }
+      raise ArgumentError, "Invalid connection name: #{name}" unless connection
+
+      connection
+    end
+  end
+end
+
+require 'chake/connection/ssh'
+require 'chake/connection/local'

data/lib/chake/{backend → connection}/local.rb

@@ -1,11 +1,8 @@
 require 'socket'
 
 module Chake
-
-  class Backend
-
-    class Local < Backend
-
+  class Connection
+    class Local < Connection
       def command_runner
         ['sh', '-c']
       end
@@ -17,9 +14,6 @@ module Chake
       def skip?
         node.hostname != Socket.gethostname
       end
-
     end
-
   end
-
 end

data/lib/chake/{backend → connection}/ssh.rb

@@ -1,15 +1,12 @@
 module Chake
-
-  class Backend
-
-    class Ssh < Backend
-
+  class Connection
+    class Ssh < Connection
       def scp
         ['scp', ssh_config, scp_options].flatten.compact
       end
 
       def scp_dest
-        ssh_target + ':'
+        "#{ssh_target}:"
       end
 
       def rsync
@@ -17,7 +14,7 @@ module Chake
       end
 
       def rsync_dest
-        [ssh_target, node.path + '/'].join(':')
+        [ssh_target, "#{node.path}/"].join(':')
       end
 
       def command_runner
@@ -35,11 +32,9 @@ module Chake
           begin
             ssh_command = 'ssh'
             if File.exist?(ssh_config_file)
-              ssh_command +=  ' -F ' + ssh_config_file
-            end
-            if node.port
-              ssh_command += ' -p ' + node.port.to_s
+              ssh_command += " -F #{ssh_config_file}"
             end
+            ssh_command += " -p #{node.port}" if node.port
             if ssh_command == 'ssh'
               []
             else
@@ -71,9 +66,6 @@ module Chake
       def scp_options
         node.port && ['-P', node.port.to_s] || []
       end
-
     end
-
   end
-
 end

data/lib/chake/node.rb

@@ -2,58 +2,78 @@ require 'uri'
 require 'etc'
 require 'forwardable'
 
-require 'chake/backend'
+require 'chake/connection'
+require 'chake/config_manager'
 
 module Chake
-
   class Node
-
     extend Forwardable
 
-    attr_reader :hostname
-    attr_reader :port
-    attr_reader :username
-    attr_reader :remote_username
-    attr_reader :path
-    attr_reader :data
+    attr_reader :hostname, :port, :username, :remote_username, :data
+
+    attr_accessor :silent
 
     def self.max_node_name_length
       @max_node_name_length ||= 0
     end
-    def self.max_node_name_length=(value)
-      @max_node_name_length = value
+
+    class << self
+      attr_writer :max_node_name_length
     end
 
     def initialize(hostname, data = {})
-      uri = URI.parse(hostname)
-      if !uri.host && ((!uri.scheme && uri.path) || (uri.scheme && uri.opaque))
-        uri = URI.parse("ssh://#{hostname}")
-      end
-      if uri.path && uri.path.empty?
-        uri.path = nil
-      end
-
-      @backend_name = uri.scheme
-
+      uri = parse_uri(hostname)
+      @connection_name = uri.scheme
       @hostname = uri.host
       @port = uri.port
       @username = uri.user || Etc.getpwuid.name
       @remote_username = uri.user
-      @path = uri.path || "/var/tmp/chef.#{username}"
+      @path = uri.path
       @data = data
+      set_max_node_length
+    end
+
+    def connection
+      @connection ||= Chake::Connection.get(@connection_name).new(self)
+    end
+
+    def_delegators :connection, :run, :run_as_root, :run_shell, :rsync, :rsync_dest, :scp, :scp_dest, :skip?
 
-      if @hostname.length > self.class.max_node_name_length
-        self.class.max_node_name_length = @hostname.length
+    def config_manager
+      @config_manager ||= Chake::ConfigManager.get(self)
+    end
+
+    def_delegators :config_manager, :converge, :apply, :path, :bootstrap_steps, :needs_bootstrap?, :needs_upload?
+
+    def path
+      @path ||= config_manager.path
+    end
+
+    def log(msg)
+      return if silent
+
+      puts("%#{Node.max_node_name_length}<host>s: %<msg>s\n" % { host: hostname, msg: msg })
+    end
+
+    private
+
+    def parse_uri(hostname)
+      uri = URI.parse(hostname)
+      if incomplete_uri(uri)
+        uri = URI.parse("ssh://#{hostname}")
       end
+      uri.path = nil if uri.path.empty?
+      uri
     end
 
-    def backend
-      @backend ||= Chake::Backend.get(@backend_name).new(self)
+    def incomplete_uri(uri)
+      !uri.host && ((!uri.scheme && uri.path) || (uri.scheme && uri.opaque))
     end
 
-    def_delegators :backend, :run, :run_as_root, :run_shell, :rsync, :rsync_dest, :scp, :scp_dest, :skip?
+    def set_max_node_length
+      return if @hostname.length <= self.class.max_node_name_length
 
+      self.class.max_node_name_length = @hostname.length
+    end
   end
-
 end
-