marionetta 0.2.2 → 0.3.0

data/README.md

@@ -39,7 +39,9 @@ servers.each_server do |s|
   cmd = Marionetta::CommandRunner.new(s)
 
   # Send a command via SSH
-  cmd.ssh('whoami')
+  cmd.ssh('whoami') do |out, err|
+    puts out.read
+  end
 
   # Get a file
   cmd.get('/var/backups/database')
@@ -70,10 +72,11 @@ end
 servers.manipulate_each_server(:puppet, :update)
 ```
 
-## Using the debloyer
+## Using the deployer
 
-Also included is a .deb deploying manipulator. You can use
-this to deploy your application over SSH as a .deb.
+Also included is a deployment mechanism similar to capistrano.
+You can use this to deploy releases of folders from a local
+machine to a remote one over SSH.
 
 ``` ruby
 require 'marionetta/group'
@@ -82,11 +85,25 @@ staging = Marionetta::Group.new(:staging)
 
 staging.add_server do |s|
   s[:hostname] = 'staging.example.com'
-  s[:debloyer][:from] = '/my-app'
-  s[:debloyer][:to] = '/home/staging/www'
+  s[:deployer][:from] = '/my-app'
+  s[:deployer][:to] = '/home/staging/www'
 end
 
-staging.manipulate_each_server(:debloyer, :deploy)
+staging.manipulate_each_server(:deployer, :deploy)
+```
+
+The deployer also supports listing releases:
+
+```
+staging.manipulate_each_server(:deployer, :releases) do |server, releases|
+  puts server[:hostname], releases
+end
+```
+
+Oh and you can rollback to the last release too!
+
+```
+staging.manipulate_each_server(:deployer, :rollback)
 ```
 
 ## Using Marionetta in your Rakefile
@@ -105,16 +122,16 @@ staging = Marionetta::Group.new(:staging)
 staging.add_server do |s|
   s[:hostname] = 'staging.example.com'
   s[:puppet][:manifest] = 'puppet/manifest.pp'
-  s[:debloyer][:from] = '/my-app'
-  s[:debloyer][:to] = '/home/staging/www'
+  s[:deployer][:from] = '/my-app'
+  s[:deployer][:to] = '/home/staging/www'
 end
 
 Marionetta::RakeHelper.new(staging).install_group_tasks
 ```
 
-The tasks `staging:puppet:install`, `staging:puppet:update`
-`staging:debloyer:deploy` will now be available in your
-Rakefile.
+The tasks `puppet:staging:install`, `puppet:staging:update`,
+`deployer:staging:deploy` and `deployer:staging:rollback`
+will now be available in your Rakefile.
 
 **Groups must have names if you want to generate rake tasks.**
 

data/lib/marionetta/command_runner.rb

@@ -3,20 +3,31 @@ require 'open4'
 module Marionetta
   class CommandRunner
     attr_reader :server
+    attr_reader :last
 
     def initialize(server)
       @server = server
     end
     
     def system(*args)
-      status = Open4::popen4(*args) do |pid, stdin, stdout, stderr|
-        yield stdout, stderr if block_given?
+      @last = args.join(' ')
+      server[:logger].info(last)
 
-        server[:logger].info(args.join(' '))
-        server[:logger].debug(stdout.read)
-        server[:logger].debug(stderr.read)
+      begin
+        status = Open4::popen4(*args) do |pid, stdin, stdout, stderr|
+          yield stdout, stderr if block_given?
+
+          [stdout, stderr].each do |io|
+            str = io.read
+            server[:logger].debug(str) unless str.empty?
+          end
+        end
+      rescue
+        server[:logger].fatal(args.join(' '))
+        server[:logger].fatal($!)
+        exit(1)
       end
-      
+
       return status.exitstatus == 0
     end
 
@@ -52,5 +63,40 @@ module Marionetta
 
       system(*ssh_cmd.flatten, &block)
     end
+
+    def archive(directory, save_to = nil)
+      if save_to.nil?
+        save_to = "#{directory}.#{server[:archive][:ext]}"
+      elsif File.directory?(save_to)
+        dirname = File.basename(directory)
+        save_to = "#{save_to}/#{dirname}.#{server[:archive][:ext]}"
+      end
+
+      archive_cmd = [
+        server[:archive][:command],
+        server[:archive][:flags],
+        save_to,
+        directory,
+      ]
+
+      system(*archive_cmd.flatten)
+    end
+
+    def ssh_extract(archive_path, save_to = File.dirname(archive_path))
+      cmds = [
+        "mkdir -p #{save_to}",
+        "cd #{save_to}",
+      ]
+
+      extract_cmd = [
+        server[:extract][:command],
+        server[:extract][:flags],
+        archive_path,
+      ]
+
+      cmds << extract_cmd.flatten.join(' ')
+
+      ssh(cmds.join(' && '))
+    end
   end
 end

data/lib/marionetta/group.rb

@@ -53,15 +53,19 @@ module Marionetta
         end
       end
 
+      return_values = []
+
       futures.each do |f|
-        f.value
+        return_values << f.value
       end
+
+      return return_values
     end
 
     def manipulate_each_server(manipulator_name, method_name)
       each_server do |s|
         manipulator = Manipulators[manipulator_name].new(s)
-        manipulator.method(method_name).call()
+        yield s, manipulator.method(method_name).call() if block_given?
       end
     end
   end

data/lib/marionetta/manipulators/deployer.rb

@@ -0,0 +1,99 @@
+require 'marionetta/command_runner'
+
+module Marionetta
+  module Manipulators
+    class Deployer
+      def self.tasks()
+        [:deploy, :rollback]
+      end
+      
+      attr_writer :cmd
+
+      def initialize(server)
+        @server = server
+      end
+
+      def deploy()
+        release = timestamp
+        release_archive = "/tmp/#{release}.tar.gz"
+        cmd.archive(from_dir, release_archive)
+        cmd.put(release_archive)
+
+        release_dir = release_dir(release)
+
+        unless cmd.ssh_extract(release_archive, release_dir)
+          server[:logger].fatal(cmd.last)
+          server[:logger].fatal('Could not extract archive')
+          exit(1)
+        end
+
+        symlink_release(release)
+      end
+
+      def releases()
+        releases = []
+
+        cmd.ssh("ls -m #{release_dir}") do |stdout|
+          stdout.read.split(/[,\s]+/).each do |release|
+            releases << release unless release.index('skip-') == 0
+          end
+        end
+
+        return releases
+      end
+
+      def rollback()
+        rollback_to_release = releases[-2]
+
+        if rollback_to_release.nil?
+          server[:logger].warn('No release to rollback to')
+        else
+          current_release_dir = release_dir(releases.last)
+          skip_current_release_dir = release_dir("skip-#{releases.last}")
+          cmd.ssh("mv #{current_release_dir} #{skip_current_release_dir}")
+          symlink_release(rollback_to_release)
+        end
+      end
+
+    private
+      
+      attr_reader :server
+
+      def cmd()
+        @cmd ||= CommandRunner.new(server)
+      end
+
+      def from_dir()
+        server[:deployer][:from]
+      end
+
+      def to_dir()
+        server[:deployer][:to]
+      end
+
+      def release_dir(release=nil)
+        dir = "#{to_dir}/releases"
+        dir << "/#{release}" unless release.nil?
+        return dir
+      end
+
+      def current_dir()
+        "#{to_dir}/current"
+      end
+
+      def symlink_release(release)
+        release_dir = release_dir(release)
+
+        unless cmd.ssh("rm -rf #{current_dir} && ln -s #{release_dir} #{current_dir}")
+          server[:logger].fatal(cmd.last)
+          server[:logger].fatal('Could not symlink release as current')
+          exit(1)
+        end
+      end
+
+      def timestamp()
+        Time.new.strftime('%F_%T')
+      end
+    end
+  end
+end

data/lib/marionetta/manipulators/puppet_manipulator.rb

@@ -61,20 +61,19 @@ module Marionetta
       end
 
       def archive_files()
+        puppet_tmp = '/tmp/puppet'
+
         cmds = [
-          'rm -rf /tmp/puppet',
-          'mkdir /tmp/puppet',
-          "cp #{server[:puppet][:manifest]} /tmp/puppet/manifest.pp",
+          "rm -rf #{puppet_tmp}",
+          "mkdir #{puppet_tmp}",
+          "cp #{server[:puppet][:manifest]} #{puppet_tmp}/manifest.pp",
         ]
 
         if server[:puppet].has_key?(:modules)
-          cmds << "cp -r #{server[:puppet][:modules]} /tmp/puppet/modules"
+          cmds << "cp -r #{server[:puppet][:modules]} #{puppet_tmp}/modules"
         end
 
-        cmds << 'cd /tmp'
-        cmds << 'tar cvfz puppet.tar.gz puppet'
-
-        cmd.system(cmds.join(' && '))
+        cmd.archive(puppet_tmp)
       end
 
       def send_archive()
@@ -82,11 +81,8 @@ module Marionetta
       end
 
       def apply_archive()
-        cmds = [
-          'cd /tmp',
-          'tar xvfz puppet.tar.gz',
-          'cd puppet',
-        ]
+        cmd.ssh_extract('/tmp/puppet.tar.gz')
+        cmds = ['cd /tmp/puppet']
 
         puppet_cmd = 'sudo puppet apply '
 

data/lib/marionetta/manipulators.rb

@@ -1,10 +1,12 @@
 module Marionetta
   module Manipulators
+    require_relative 'manipulators/deployer'
     require_relative 'manipulators/debloyer'
     require_relative 'manipulators/puppet_manipulator'
 
     def self.all()
       {
+        :deployer => Deployer,
         :debloyer => Debloyer,
         :puppet   => PuppetManipulator,
       }

data/lib/marionetta.rb

@@ -1,5 +1,5 @@
 module Marionetta
-  VERSION     = '0.2.2'
+  VERSION     = '0.3.0'
   DESCRIPTION = 'For lightweight puppet mastery. Organise
                  multiple machines via rsync and SSH rather
                  than using puppet master'
@@ -15,9 +15,22 @@ module Marionetta
 
       :rsync => {
         :command => 'rsync',
-        :flags   => ["-azP", "--delete"],
+        :flags   => ['-azP', '--delete'],
       },
 
+      :archive => {
+        :command => 'tar',
+        :flags => ['-zvcf'],
+        :ext => 'tar.gz',
+      },
+
+      :extract => {
+        :command => 'tar',
+        :flags => ['-xvf'],
+      },
+
+      :deployer => {},
+
       :debloyer => {
         :name => 'debloyer',
         :fpm => {

data/spec/deployer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require "marionetta"
+require "marionetta/manipulators/deployer"
+
+def deployer()
+  Marionetta::Manipulators::Deployer.new(server)
+end
+
+describe Marionetta::Manipulators::Deployer do
+  it 'should deploy' do
+    deployer.deploy
+  end
+
+  it 'should list releases' do
+    deployer.releases.length.should > 0
+  end
+
+  it 'should rollback' do
+    deployer.rollback
+  end
+end

data/spec/{marionetta_group_spec.rb → group_spec.rb}

@@ -84,6 +84,8 @@ describe Marionetta::Group do
   it 'should manipulate each server' do
     vagrant = Marionetta::Group.new
     vagrant.add_server(server)
-    vagrant.manipulate_each_server(:puppet, :update)
+    vagrant.manipulate_each_server(:deployer, :releases) do |server, releases|
+      releases.length.should > 0
+    end
   end
 end

data/spec/{marionetta_rake_helper_spec.rb → rake_helper_spec.rb}

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'marionetta/group'
 require 'marionetta/rake_helper'
 
 describe Marionetta::RakeHelper do
@@ -10,6 +11,7 @@ describe Marionetta::RakeHelper do
     Rake::Task.tasks.count.should > 0
 
     Rake::Task['puppet:vagrant:update'].invoke
-    Rake::Task['debloyer:vagrant:deploy'].invoke
+    Rake::Task['deployer:vagrant:deploy'].invoke
+    Rake::Task['deployer:vagrant:rollback'].invoke
   end
 end

data/spec/spec_helper.rb

@@ -15,6 +15,9 @@ def server()
     s[:ssh][:flags] = ['-i', ssh_key_path]
     s[:rsync][:flags] = ['-azP', '-e', "ssh -i #{ssh_key_path}", '--delete']
 
+    s[:deployer][:from] = File.dirname(__FILE__)+'/app'
+    s[:deployer][:to] = '/home/vagrant'
+
     s[:debloyer][:from] = File.dirname(__FILE__)+'/app'
     s[:debloyer][:to] = '/home/vagrant'
     s[:debloyer][:name] = 'test'

data/spec/ssh_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'marionetta/command_runner'
+
+def cmd()
+  Marionetta::CommandRunner.new(server)
+end
+
+describe Marionetta::CommandRunner do
+  it 'should provide stdout and stderr via block' do
+    cmd.system('whoami') do |stdout, stderr|
+      stdout.read.strip.should == ENV['USER']
+    end
+  end
+
+  it 'should get file' do
+    cmd.get('/etc/hostname', '/tmp/hosting')
+    File.open('/tmp/hosting', 'rb').read.should == "precise64\n"
+  end
+
+  it 'should put file' do
+    file_path = "#{LIB}/marionetta.rb"
+    cmd.put(file_path, '/tmp')
+    local = File.open(file_path, 'rb').read
+
+    tmp_path = '/tmp/marionetta.rb'
+    cmd.get(tmp_path)
+    remote = File.open(tmp_path, 'rb').read
+    remote.should == local
+  end
+
+  it 'should run commands' do
+    cmd.ssh('whoami') do |stdout, stderr|
+      stdout.read.strip.should == 'vagrant'
+    end
+  end
+
+  it 'should archive directory' do
+    cmd.archive(LIB)
+    File.exists?("#{LIB}.tar.gz").should == true
+    system('rm', "#{LIB}.tar.gz")
+  end
+
+  it 'should archive directory to specified path' do
+    cmd.archive(LIB, '/tmp')
+    File.exists?("/tmp/lib.tar.gz").should == true
+  end
+
+  it 'should archive directory to specified file' do
+    cmd.archive(LIB, '/tmp/custom.archive')
+    File.exists?('/tmp/custom.archive').should == true
+  end
+
+  it 'should extract an archive over ssh' do
+    cmd.archive(LIB, '/tmp')
+    cmd.put('/tmp/lib.tar.gz')
+    cmd.ssh_extract('/tmp/lib.tar.gz')
+    cmd.ssh("[ -d /tmp/lib ]").should == true
+    cmd.ssh("[ -d /tmp/lib/lib ]").should_not == true
+  end
+
+  it 'should extract an archive over ssh into specific folder' do
+    cmd.archive(LIB, '/tmp')
+    cmd.put('/tmp/lib.tar.gz')
+    cmd.ssh_extract('/tmp/lib.tar.gz', '/tmp/other')
+    cmd.ssh("[ -d /tmp/other ]").should == true
+    cmd.ssh("[ -d /tmp/other/lib ]").should == true
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marionetta
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-18 00:00:00.000000000 Z
+date: 2012-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: open4
@@ -124,20 +124,22 @@ files:
 - lib/marionetta/group.rb
 - lib/marionetta/manipulators.rb
 - lib/marionetta/manipulators/debloyer.rb
+- lib/marionetta/manipulators/deployer.rb
 - lib/marionetta/manipulators/puppet_manipulator.rb
 - lib/marionetta/rake_helper.rb
 - lib/test.rb
 - marionetta.gemspec
 - spec/app/app.rb
-- spec/marionetta_debloyer_spec.rb
-- spec/marionetta_group_spec.rb
-- spec/marionetta_manipulators_spec.rb
-- spec/marionetta_puppet_manipulator_spec.rb
-- spec/marionetta_rake_helper_spec.rb
+- spec/debloyer_spec.rb
+- spec/deployer_spec.rb
+- spec/group_spec.rb
+- spec/manipulators_spec.rb
 - spec/marionetta_spec.rb
-- spec/marionetta_ssh_spec.rb
 - spec/puppet/manifest.pp
+- spec/puppet_manipulator_spec.rb
+- spec/rake_helper_spec.rb
 - spec/spec_helper.rb
+- spec/ssh_spec.rb
 - spec/vagrant/Vagrantfile
 - spec/vagrant/key
 homepage: https://github.com/DrPheltRight/marionetta
@@ -167,14 +169,15 @@ summary: For lightweight puppet mastery. Organise multiple machines via rsync an
   SSH rather than using puppet master
 test_files:
 - spec/app/app.rb
-- spec/marionetta_debloyer_spec.rb
-- spec/marionetta_group_spec.rb
-- spec/marionetta_manipulators_spec.rb
-- spec/marionetta_puppet_manipulator_spec.rb
-- spec/marionetta_rake_helper_spec.rb
+- spec/debloyer_spec.rb
+- spec/deployer_spec.rb
+- spec/group_spec.rb
+- spec/manipulators_spec.rb
 - spec/marionetta_spec.rb
-- spec/marionetta_ssh_spec.rb
 - spec/puppet/manifest.pp
+- spec/puppet_manipulator_spec.rb
+- spec/rake_helper_spec.rb
 - spec/spec_helper.rb
+- spec/ssh_spec.rb
 - spec/vagrant/Vagrantfile
 - spec/vagrant/key

data/spec/marionetta_ssh_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'marionetta/command_runner'
-
-def cmd()
-  Marionetta::CommandRunner.new(server)
-end
-
-describe Marionetta::CommandRunner do
-  it 'should get file' do
-    cmd.get('/etc/hostname', '/tmp/hosting')
-    File.open('/tmp/hosting', 'rb').read.should == "precise64\n"
-  end
-
-  it 'should put file' do
-    file_path = "#{LIB}/marionetta.rb"
-    cmd.put(file_path, '/tmp')
-    local = File.open(file_path, 'rb').read
-
-    tmp_path = '/tmp/marionetta.rb'
-    cmd.get(tmp_path)
-    remote = File.open(tmp_path, 'rb').read
-    remote.should == local
-  end
-
-  it 'should run commands' do
-    cmd.ssh('whoami') do |stdout, stderr|
-      stdout.read.should == "vagrant\n"
-    end
-  end
-end