chake 0.20 → 0.81

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_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
-

data/lib/chake/readline.rb

@@ -4,11 +4,8 @@ require 'readline'
 require 'chake/tmpdir'
 
 module Chake
-
   class Readline
-
     class << self
-
       def history_file
         raise NotImplementedError
       end
@@ -22,12 +19,14 @@ module Chake
       end
 
       def init
-        return if !File.exists?(history_file)
+        return unless File.exist?(history_file)
+
         @history = File.readlines(history_file).map(&:strip)
       end
 
       def finish
         return if !File.writable?(File.dirname(history_file)) || history.empty?
+
         File.open(history_file, 'w') do |f|
           history.last(500).each do |line|
             f.puts(line)
@@ -41,18 +40,16 @@ module Chake
           ::Readline::HISTORY.push(cmd)
         end
         input = ::Readline.readline(prompt)
-        if input && input.strip != '' && input != @last
-          history.push(input)
-        end
+        history.push(input) if input && input.strip != '' && input != @last
         input
       end
-
     end
 
     class Commands < Readline
       def self.history_file
         File.join(Chake.tmpdir, '.commands_history')
       end
+
       def self.prompt
         '$ '
       end
@@ -62,13 +59,12 @@ module Chake
       def self.history_file
         File.join(Chake.tmpdir, '.recipes_history')
       end
+
       def self.prompt
         '> '
       end
     end
-
   end
-
 end
 
 Chake::Readline.constants.each do |subclass|

data/lib/chake/version.rb

@@ -1,3 +1,3 @@
 module Chake
-  VERSION = "0.20"
+  VERSION = '0.81'.freeze
 end

data/lib/chake/wipe.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+
+module Chake
+  class Wipe
+    include Singleton
+
+    if system('which', 'wipe', out: '/dev/null', err: :out)
+      def wipe(file)
+        system('wipe', '-rfs', file)
+      end
+    else
+      warn 'W: please install "wipe" program for secure deletion, falling back to unlink(2)'
+      def wipe(file)
+        File.unlink(file)
+      end
+    end
+  end
+end

data/man/.gitignore

@@ -0,0 +1,2 @@
+chake.1*
+chake.adoc

data/man/Rakefile

@@ -1,22 +1,36 @@
-task :default => 'man/chake.1'
+MAIN_MANPAGE = 'man/chake.1'.freeze
+OTHER_MANPAGES = %w[
+  man/chake-chef.7
+  man/chake-itamae.7
+  man/chake-shell.7
+].freeze
+MANPAGES = [MAIN_MANPAGE] + OTHER_MANPAGES
 
-file 'man/chake.1' => ['man/chake.adoc'] do
-  sh 'asciidoctor --backend manpage --out-file man/chake.1 man/chake.adoc'
-end
+task default: :man
+task man: MANPAGES
 
-file 'man/chake.adoc' => ['README.md', 'man/readme2man.sed'] do |t|
-  sh "sed -f man/readme2man.sed README.md > #{t.name} || (rm -f #{t.name}; false)"
+MANPAGES.each do |man|
+  source = "README#{man.pathmap('%n').sub(/^chake/, '').sub('-', '.')}.md"
+  file man => [source, 'man/readme2man.sed'] do
+    sh "sed -f man/readme2man.sed #{source} > #{man}.ronn || (rm -f #{man}.ronn; false)"
+    sh "ronn --roff #{man}.ronn"
+    sh "rm -f #{man}.ronn"
+    sh 'sed', '-i', '-e', 's/\\\\\'/\'/', man
+  end
 end
 
-task :install => 'man/chake.1' do
-  prefix = ENV['PREFIX'] || File.exists?('debian/rules') && '/usr' || '/usr/local'
-  target = [ENV["DESTDIR"], prefix , 'share/man/man1'].compact
-  man = File.join(*target)
-  sh 'install', '-d', '-m', '0755', man
-  sh 'install', '-m', '0644', 'man/chake.1', man
+task install: MANPAGES do
+  prefix = ENV['PREFIX'] || File.exist?('debian/rules') && '/usr' || '/usr/local'
+  man1 = File.join(*[ENV['DESTDIR'], prefix, 'share/man/man1'].compact)
+  man7 = File.join(*[ENV['DESTDIR'], prefix, 'share/man/man7'].compact)
+  target = { '.1' => man1, '.7' => man7 }
+  sh 'install', '-d', '-m', '0755', man1
+  sh 'install', '-d', '-m', '0755', man7
+  MANPAGES.each do |m|
+    sh 'install', '-m', '0644', m, target[m.pathmap('%x')]
+  end
 end
 
 task :clean do
-  rm_f 'man/chake.1'
-  rm_f 'man/chake.adoc'
+  rm_f MANPAGES
 end

data/man/readme2man.sed

@@ -1,6 +1,6 @@
-1a :doctype: manpage
-
-/^## Install/,/^[^#]/ d
-/^## Contributing/,$ d
-
+# Capitalize section titles
 s/^\(##\+\)\(.*\)/\1 \U\2/
+
+# Turn fenced code blocks into 4-space indented blocks
+/^```/,/```/ s/^/    /
+/^    ```.*/ d

data/spec/chake/backend/local_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
-describe Chake::Backend::Local do
+describe Chake::Connection::Local do
+  include_examples 'Chake::Connection', Chake::Connection::Local
 
-  include_examples "Chake::Backend", Chake::Backend::Local
+  let(:node) { Chake::Node.new('local://myusername@myhost/srv/chake') }
 
-  let(:node) { Chake::Node.new('local://myusername@myhost/srv/chef') }
+  it('runs commands with sh -c') { expect(connection.command_runner).to eq(['sh', '-c']) }
 
-  it('runs commands with sh -c') { expect(backend.command_runner).to eq(['sh', '-c']) }
-
-  it('rsyncs locally') { expect(backend.rsync_dest).to eq('/srv/chef/') }
+  it('rsyncs locally') { expect(connection.rsync_dest).to eq('/srv/chake/') }
 
   it('skips if hostname is not the local hostname') do
     allow(Socket).to receive(:gethostname).and_return('otherhost')

data/spec/chake/backend/ssh_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
-describe Chake::Backend::Ssh do
+describe Chake::Connection::Ssh do
+  include_examples 'Chake::Connection', Chake::Connection::Ssh
 
-  include_examples "Chake::Backend", Chake::Backend::Ssh
+  let(:node) { Chake::Node.new('ssh://myuser@myhost/srv/chake') }
 
-  let(:node) { Chake::Node.new('ssh://myuser@myhost/srv/chef') }
+  it('runs commands with ssh') { expect(connection.command_runner).to eq(['ssh', 'myuser@myhost']) }
 
-  it('runs commands with ssh') { expect(backend.command_runner).to eq(['ssh', 'myuser@myhost']) }
-
-  it('rsyncs over ssh') { expect(backend.rsync_dest).to eq('myuser@myhost:/srv/chef/') }
+  it('rsyncs over ssh') { expect(connection.rsync_dest).to eq('myuser@myhost:/srv/chake/') }
 
   it 'uses no remote username if none was passed' do
     node = Chake::Node.new('theserver')
@@ -24,14 +23,13 @@ describe Chake::Backend::Ssh do
   context 'with a custom port' do
     let(:node) { Chake::Node.new('ssh://myhost:2222') }
     it 'uses port with ssh' do
-      expect(backend.command_runner).to eq(['ssh', '-p', '2222', 'myhost'])
+      expect(connection.command_runner).to eq(['ssh', '-p', '2222', 'myhost'])
     end
     it 'uses port with scp' do
-      expect(backend.scp).to eq(['scp', '-P', '2222'])
+      expect(connection.scp).to eq(['scp', '-P', '2222'])
     end
     it 'uses port with rsync' do
-      expect(backend.send(:rsync_ssh)).to eq(['-e', 'ssh -p 2222'])
+      expect(connection.send(:rsync_ssh)).to eq(['-e', 'ssh -p 2222'])
     end
   end
-
 end

data/spec/chake/backend_spec.rb

@@ -1,2 +1 @@
-require 'chake/backend'
-
+require 'chake/connection'

data/spec/chake/config_manager/chef_spec.rb

@@ -0,0 +1,38 @@
+require 'chake/node'
+require 'chake/config_manager/chef'
+
+describe Chake::ConfigManager::Chef do
+  let(:node) do
+    Chake::Node.new('foobar')
+  end
+
+  subject do
+    Chake::ConfigManager::Chef.new(node)
+  end
+
+  it 'provides a name' do
+    expect(subject.name).to eq('chef')
+  end
+
+  it 'calls chef-solo on converge' do
+    expect(subject).to receive(:logging).and_return('-l debug')
+    expect(node).to receive(:run_as_root).with(%r{chef-solo -c #{node.path}/config.rb -l debug -j #{node.path}/#{Chake.tmpdir}/foobar.json})
+    subject.converge
+  end
+
+  it 'calls chef-solo on apply' do
+    expect(subject).to receive(:logging).and_return('-l debug')
+    expect(node).to receive(:run_as_root).with(%r{chef-solo -c #{node.path}/config.rb -l debug -j #{node.path}/#{Chake.tmpdir}/foobar.json --override-runlist recipe\[myrecipe\]})
+    subject.apply('myrecipe')
+  end
+
+  context 'logging' do
+    it 'logs when requested' do
+      expect(subject.send(:logging)).to eq('')
+    end
+    it 'only show fatal errrrs when requested' do
+      node.silent = true
+      expect(subject.send(:logging)).to eq('-l fatal')
+    end
+  end
+end

data/spec/chake/config_manager/itamae_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'chake/node'
+require 'chake/config_manager/itamae'
+
+describe Chake::ConfigManager::Itamae do
+  let(:hostname) { 'foobar' }
+  let(:node) do
+    Chake::Node.new(hostname).tap do |n|
+      n.silent = true
+      n.data['itamae'] = ['foo.rb', 'bar.rb']
+    end
+  end
+  let(:cfg) { Chake::ConfigManager::Itamae.new(node) }
+  let(:output) { StringIO.new("line1\nline2\n") }
+
+  it 'does not require uploading' do
+    expect(cfg.needs_upload?).to eq(false)
+  end
+
+  it 'calls itamae when converging' do
+    expect(IO).to receive(:popen).with(
+      array_including('itamae', 'foo.rb', 'bar.rb'),
+      'r',
+      err: %i[child out]
+    ).and_return(output)
+    cfg.converge
+  end
+
+  it 'calls itamae when applying' do
+    expect(IO).to receive(:popen).with(
+      array_including('itamae', 'foobarbaz.rb'),
+      'r',
+      err: %i[child out]
+    ).and_return(output)
+    cfg.apply('foobarbaz.rb')
+  end
+
+  context 'for ssh hosts' do
+    let(:hostname) { 'ssh://theusernanme@thehostname' }
+    it 'calls itamae ssh subcommand' do
+      expect(IO).to receive(:popen).with(
+        array_including('itamae', 'ssh', '--host=thehostname', '--user=theusernanme'),
+        anything,
+        err: anything
+      ).and_return(output)
+      cfg.converge
+    end
+  end
+
+  context 'for local hosts' do
+    let(:hostname) { 'local://localhostname' }
+    it 'calls itamae with local subcommand' do
+      expect(IO).to receive(:popen).with(
+        array_including('itamae', 'local', /--node-json=.*/, 'foo.rb', 'bar.rb'),
+        anything,
+        err: anything
+      ).and_return(output)
+      cfg.converge
+    end
+  end
+
+  it 'throws an error for unsupported connection' do
+    allow(node).to receive(:connection).and_return(Object.new)
+    expect(-> { cfg.converge }).to raise_error(NotImplementedError)
+  end
+
+  it 'handles silent mode' do
+    expect(IO).to receive(:popen).with(
+      array_including('--log-level=warn'),
+      anything,
+      err: anything
+    ).and_return(output)
+    cfg.converge
+  end
+
+  RSpec::Matchers.define_negated_matcher :array_excluding, :include
+
+  it 'handles non-silent mode' do
+    node.silent = false
+    expect(IO).to receive(:popen).with(
+      array_excluding('--log-level=warn'),
+      anything,
+      err: anything
+    ).and_return(output)
+    silence($stdout) { cfg.converge }
+  end
+end