chake 0.19 → 0.80

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.19"
+  VERSION = '0.80'.freeze
 end

data/man/Rakefile

@@ -1,22 +1,35 @@
-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"
+  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,69 @@
+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 bootstrapping' do
+    expect(cfg.needs_bootstrap?).to eq(false)
+  end
+
+  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(
+        ['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
+end

data/spec/chake/config_manager/shell_spec.rb

@@ -0,0 +1,54 @@
+require 'chake/node'
+require 'chake/config_manager'
+require 'chake/config_manager/shell'
+
+describe Chake::ConfigManager::Shell do |_c|
+  let(:node) do
+    Chake::Node.new('foobar').tap do |n|
+      allow(n).to receive(:path).and_return(nil)
+    end
+  end
+  it 'accepts node with explicit config_manager in data' do
+    node.data['config_manager'] = 'shell'
+    expect(Chake::ConfigManager.get(node)).to be_a(Chake::ConfigManager::Shell)
+  end
+  it 'accepts node with `shell` in data' do
+    node.data['shell'] = ['date']
+    expect(Chake::ConfigManager.get(node)).to be_a(Chake::ConfigManager::Shell)
+  end
+
+  let(:subject) { Chake::ConfigManager::Shell.new(node) }
+
+  it 'calls all shell commands on converge' do
+    node.data['shell'] = %w[date true]
+    expect(node).to receive(:run_as_root).with("sh -xec 'date && true'")
+    subject.converge
+  end
+
+  it 'changes to node path to run commands' do
+    node.data['shell'] = %w[true]
+    allow(node).to receive(:path).and_return('/foo')
+    expect(node).to receive(:run_as_root).with("sh -xec 'cd /foo && true'")
+    subject.converge
+  end
+
+  it 'calls given shell command on apply' do
+    node.data['shell'] = %w[date true]
+    expect(node).to receive(:run_as_root).with("sh -xec 'reboot'")
+    subject.apply('reboot')
+  end
+
+  it 'hides output on converge in silent mode' do
+    node.data['shell'] = ['date']
+    node.silent = true
+    expect(node).to receive(:run_as_root).with("sh -ec 'date' >/dev/null")
+    subject.converge
+  end
+
+  it 'hides output on apply in silent mode' do
+    node.data['shell'] = ['date']
+    node.silent = true
+    expect(node).to receive(:run_as_root).with("sh -ec 'reboot' >/dev/null")
+    subject.apply('reboot')
+  end
+end

data/spec/chake/config_manager_spec.rb

@@ -0,0 +1,24 @@
+require 'pathname'
+require 'chake/node'
+require 'chake/config_manager'
+
+describe Chake::ConfigManager do
+  subject { Chake::ConfigManager.new(Chake::Node.new('ssh://user@hostname.tld')) }
+  it 'provides a path' do
+    allow(subject).to receive(:name).and_return('xyz')
+    expect(subject.path).to eq('/var/tmp/xyz.user')
+  end
+
+  it 'provides bootstrap scripts' do
+    bootstrap_steps = subject.bootstrap_steps
+    expect(bootstrap_steps).to_not be_empty
+    bootstrap_steps.each do |path|
+      expect(Pathname(path)).to exist
+    end
+  end
+
+  it 'requires uploading and bootstrapping by default' do
+    expect(subject.needs_upload?).to eq(true)
+    expect(subject.needs_bootstrap?).to eq(true)
+  end
+end

data/spec/chake/node_spec.rb

@@ -1,7 +1,6 @@
 require 'chake/node'
 
 describe Chake::Node do
-
   before do
     ent = double
     allow(ent).to receive(:name).and_return('jonhdoe')
@@ -10,23 +9,24 @@ describe Chake::Node do
 
   let(:simple) { Chake::Node.new('hostname') }
   it('has a name') { expect(simple.hostname).to eq('hostname') }
-  it('uses ssh by default') { expect(simple.backend).to be_an_instance_of(Chake::Backend::Ssh) }
+  it('uses ssh by default') { expect(simple.connection).to be_an_instance_of(Chake::Connection::Ssh) }
   it('user current username by default') {
     expect(simple.username).to eq('jonhdoe')
   }
-  it('writes to /var/tmp/chef.$username') {
-    expect(simple.path).to eq('/var/tmp/chef.jonhdoe')
+  it('writes to specified path') {
+    node = Chake::Node.new('ssh://host.tld/path/to/config')
+    expect(node.path).to eq('/path/to/config')
   }
 
   let(:with_username) { Chake::Node.new('username@hostname') }
   it('accepts username') { expect(with_username.username).to eq('username') }
-  it('uses ssh') { expect(with_username.backend).to be_an_instance_of(Chake::Backend::Ssh) }
+  it('uses ssh') { expect(with_username.connection).to be_an_instance_of(Chake::Connection::Ssh) }
 
-  let(:with_backend) { Chake::Node.new('local://hostname')}
-  it('accepts backend as URI scheme') { expect(with_backend.backend).to be_an_instance_of(Chake::Backend::Local) }
+  let(:with_connection) { Chake::Node.new('local://hostname') }
+  it('accepts connection as URI scheme') { expect(with_connection.connection).to be_an_instance_of(Chake::Connection::Local) }
 
-  it('wont accept any backend') do
-    expect { Chake::Node.new('foobar://bazqux').backend }.to raise_error(ArgumentError)
+  it('wont accept any connection') do
+    expect { Chake::Node.new('foobar://bazqux').connection }.to raise_error(ArgumentError)
   end
 
   let(:with_data) { Chake::Node.new('local://localhost', 'run_list' => ['recipe[common]']) }
@@ -42,20 +42,43 @@ describe Chake::Node do
   let(:with_port_but_no_scheme) { Chake::Node.new('foo.bar.com:2222') }
   it('accepts a port specification without a scheme') do
     expect(with_port_but_no_scheme.port).to eq(2222)
-    expect(with_port_but_no_scheme.backend.to_s).to eq('ssh')
+    expect(with_port_but_no_scheme.connection.to_s).to eq('ssh')
   end
 
-  [:run, :run_as_root, :rsync_dest].each do |method|
-    it("delegates #{method} to backend") do
+  %i[run run_as_root rsync_dest].each do |method|
+    it("delegates #{method} to connection") do
       node = simple
 
-      backend = double
+      connection = double
       args = Object.new
-      allow(node).to receive(:backend).and_return(backend)
+      allow(node).to receive(:connection).and_return(connection)
 
-      expect(backend).to receive(method).with(args)
+      expect(connection).to receive(method).with(args)
       node.send(method, args)
     end
   end
 
+  it 'delegates converge to config_manager' do
+    node = simple
+    expect(node.config_manager).to receive(:converge)
+    node.converge
+  end
+
+  it 'delegates apply to config_manager' do
+    node = simple
+    expect(node.config_manager).to receive(:apply).with('myrecipe')
+    node.apply('myrecipe')
+  end
+
+  it 'falls back to writing to path specified by config manager' do
+    expect(simple.path).to eq(simple.config_manager.path)
+  end
+
+  it 'calculates max node name length' do
+    Chake::Node.max_node_name_length = 0
+    Chake::Node.new('foobar')
+    expect(Chake::Node.max_node_name_length).to eq(6)
+    Chake::Node.new('foobarbaz')
+    expect(Chake::Node.max_node_name_length).to eq(9)
+  end
 end