marionetta 0.3.2 → 0.3.3

data/lib/marionetta/manipulators/deployer.rb

@@ -24,11 +24,15 @@ module Marionetta
       end
 
       def deploy()
+        run_script(:before)
+
         release = timestamp
         create_tmp_release_dir(release)
         send_tmp_release_dir_as_archive(release)
         extract_archive_into_release_dir(release)
         symlink_release_dir(release)
+
+        run_script(:after)
       end
 
       def releases()
@@ -90,34 +94,57 @@ module Marionetta
         "#{to_dir}/current"
       end
 
+      def fatal(message)
+        server[:logger].fatal(cmd.last)
+        server[:logger].fatal(message)
+        exit(1)
+      end
+
+      def run_script(script)
+        script_key = "#{script}_script".to_sym
+
+        if server[:deployer].has_key?(script_key)
+          script = server[:deployer][script_key]
+          cmd.put(script, '/tmp')
+          tmp_script = "/tmp/#{File.basename(script)}"
+          cmd.ssh("chmod +x #{tmp_script} && exec #{tmp_script}")
+        end
+      end
+
       def create_tmp_release_dir(release)
-        cmd.system("cp -r #{from_dir} #{tmp_release_dir(release)}")
+        tmp_release_dir = tmp_release_dir(release)
+        cmd.system("cp -r #{from_dir} #{tmp_release_dir}")
+
+        if server[:deployer].has_key?(:exclude)
+          exclude_files = server[:deployer][:exclude]
+          exclude_files.map! {|f| "#{tmp_release_dir}/#{f}"}
+          cmd.system("rm -rf #{exclude_files.join(' ')}")
+        end
       end
 
       def send_tmp_release_dir_as_archive(release)
         release_archive = tmp_release_archive(release) 
-        cmd.archive(tmp_release_dir(release), release_archive)
+        
+        unless cmd.archive(tmp_release_dir(release), release_archive)
+          fatal('Could not create archive')
+        end
+
         cmd.put(release_archive)
       end
 
       def extract_archive_into_release_dir(release)
         release_archive = tmp_release_archive(release)
-        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)
+          fatal('Could not extract archive')
         end
       end
 
       def symlink_release_dir(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)
+        unless cmd.ssh("rm -f #{current_dir} && ln -s #{release_dir} #{current_dir}")
+          fatal('Could not symlink release as current')
         end
       end
 

data/lib/marionetta/manipulators/puppet_manipulator.rb

@@ -89,19 +89,19 @@ module Marionetta
         cmd.ssh_extract('/tmp/puppet.tar.gz')
         cmds = ['cd /tmp/puppet']
 
-        puppet_cmd = 'sudo puppet apply '
+        puppet_cmd = ['sudo puppet apply']
 
         if server[:puppet].has_key?(:modules)
-          puppet_cmd += '--modulepath=/tmp/puppet/modules '
+          puppet_cmd << '--modulepath=/tmp/puppet/modules'
         end
 
-        puppet_cmd += 'manifest.pp'
+        puppet_cmd << 'manifest.pp'
 
-        if server[:puppet].has_key?(:options)
-          puppet_cmd += " #{server[:puppet][:options]}"
+        if server[:puppet].has_key?(:flags)
+          puppet_cmd << server[:puppet][:flags]
         end
 
-        cmds << puppet_cmd
+        cmds << puppet_cmd.flatten.join(' ')
         
         cmd.ssh(cmds.join(' && '))
       end

data/lib/marionetta.rb

@@ -1,9 +1,43 @@
+# Marionetta is a ruby library for executing commands to one
+# or more remote machines via SSH.
+# 
+# It provides puppet provisioning without the need for a
+# puppet master and can also deploy your application code
+# (with rollbacks) via rsync. With a RakeHelper you can
+# integrate it into your workflow with ease.
+# 
+# Installing the gem is the best way to start using
+# Marionetta. You can do this from command line:
+# 
+#   gem install marionetta
+# 
+# Or – better yet – in your Gemfile:
+# 
+#   source "http://rubygems.org"
+#   gem 'marionetta'
+# 
+# Marionetta is written by [Luke Morton][author] and licensed
+# under the MIT license. The project is [hosted on github][github]
+# where you can report issues and send your well thought out
+# pull requests.
+# 
+# [author]: http://lukemorton.co.uk
+# [github]: https://github.com/DrPheltRight/marionetta
 module Marionetta
-  VERSION     = '0.3.2'
-  DESCRIPTION = 'For lightweight puppet mastery. Organise
-                 multiple machines via rsync and SSH rather
-                 than using puppet master'
+  VERSION = '0.3.3'
 
+  # In order to connect to servers you must define configs for
+  # each. This method provides a default map describing some
+  # common settings including command binaries, default flags
+  # and more.
+  # 
+  # One interesting this to note is a logger is set, pointing
+  # to `STDOUT`.
+  # 
+  # Do not get too caught up in this method, it is called
+  # elsewhere in Marionetta where you can better define your
+  # servers. You should consult this method in order to see
+  # the defaults.
   def self.default_server()
     {
       :logger => Logger.new($stdout),

data/marionetta.gemspec

@@ -6,9 +6,14 @@ Gem::Specification.new do |s|
   s.homepage    = 'https://github.com/DrPheltRight/marionetta'
   s.authors     = ["Luke Morton"]
   s.email       = ["lukemorton.dev@gmail.com"]
-  s.summary     = Marionetta::DESCRIPTION
-  s.description = Marionetta::DESCRIPTION
-
+  s.summary     = "Provision using puppet and deploy your servers over SSH."
+  s.description = "Marionetta is a ruby library for executing commands to one
+                   or more remote machines via SSH. It provides puppet
+                   provisioning without the need for a puppet master and can
+                   also deploy your application code (with rollbacks) via
+                   rsync. With a RakeHelper you can integrate it into your
+                   workflow with ease."
+                   
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- spec/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map {|f| File.basename(f)}

data/spec/app/after

@@ -0,0 +1 @@
+cp ~/app/current/app.rb ~/app/current/app-copy.rb

data/spec/app/exclude/another.txt

@@ -0,0 +1 @@
+exclude me

data/spec/app/exclude.txt

@@ -0,0 +1 @@
+exclude me

data/spec/deployer_spec.rb

@@ -6,9 +6,21 @@ def deployer()
   Marionetta::Manipulators::Deployer.new(server)
 end
 
+def cmd()
+  Marionetta::CommandRunner.new(server)
+end
+
 describe Marionetta::Manipulators::Deployer do
   it 'should deploy' do
+    cmd.ssh('rm -rf ~/app')
     deployer.deploy
+    cmd.ssh("[ -d ~/app/current ]").should == true
+    cmd.ssh("[ -d ~/app/releases ]").should == true
+    cmd.ssh("[ -f ~/app/current/app.rb ]").should == true
+    cmd.ssh("[ -f ~/app/current/app-copy.rb ]").should == true
+    cmd.ssh("[ -f ~/app/current/exclude.txt ]").should_not == true
+    cmd.ssh("[ -f ~/app/current/exclude/another.txt ]").should_not == true
+    cmd.ssh("[ -f ~/app/current/after ]").should_not == true
   end
 
   it 'should list releases' do

data/spec/spec_helper.rb

@@ -8,23 +8,30 @@ env = Vagrant::Environment.new(:cwd => File.dirname(__FILE__)+'/vagrant')
 env.cli('up')
 
 def server()
-    s = Marionetta.default_server
+  s = Marionetta.default_server
 
-    s[:hostname] = 'vagrant@192.168.33.11'
-    ssh_key_path = File.dirname(__FILE__)+'/vagrant/key'
-    s[:ssh][:flags] = ['-i', ssh_key_path]
-    s[:rsync][:flags] = ['-azP', '-e', "ssh -i #{ssh_key_path}", '--delete']
+  # s[:logger].level = Logger::INFO
 
-    s[:deployer][:from] = File.dirname(__FILE__)+'/app'
-    s[:deployer][:to] = '/home/vagrant'
+  s[:hostname] = 'vagrant@192.168.33.11'
 
-    s[:debloyer][:from] = File.dirname(__FILE__)+'/app'
-    s[:debloyer][:to] = '/home/vagrant'
-    s[:debloyer][:name] = 'test'
+  ssh_key_path = File.dirname(__FILE__)+'/vagrant/key'
+  s[:ssh][:flags] = ['-i', ssh_key_path]
+  s[:rsync][:flags] = ['-azP', '-e', "ssh -i #{ssh_key_path}", '--delete']
 
-    s[:puppet] = {
-      :manifest => File.dirname(__FILE__)+'/puppet/manifest.pp',
-    }
+  app_dir = File.dirname(__FILE__)+'/app'
 
-    return s
+  s[:deployer][:from] = app_dir
+  s[:deployer][:to] = '~/app'
+  s[:deployer][:exclude] = ['exclud*', 'before', 'after']
+  s[:deployer][:after_script] = "#{app_dir}/after"
+
+  s[:debloyer][:from] = app_dir
+  s[:debloyer][:to] = '~/app-deb'
+  s[:debloyer][:name] = 'test'
+
+  s[:puppet] = {
+    :manifest => File.dirname(__FILE__)+'/puppet/manifest.pp',
+  }
+
+  return s
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marionetta
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
   prerelease: 
 platform: ruby
 authors:
@@ -107,8 +107,11 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "For lightweight puppet mastery. Organise\n                 multiple
-  machines via rsync and SSH rather\n                 than using puppet master"
+description: ! "Marionetta is a ruby library for executing commands to one\n                   or
+  more remote machines via SSH. It provides puppet\n                   provisioning
+  without the need for a puppet master and can\n                   also deploy your
+  application code (with rollbacks) via\n                   rsync. With a RakeHelper
+  you can integrate it into your\n                   workflow with ease."
 email:
 - lukemorton.dev@gmail.com
 executables: []
@@ -128,7 +131,10 @@ files:
 - lib/marionetta/manipulators/puppet_manipulator.rb
 - lib/marionetta/rake_helper.rb
 - marionetta.gemspec
+- spec/app/after
 - spec/app/app.rb
+- spec/app/exclude.txt
+- spec/app/exclude/another.txt
 - spec/debloyer_spec.rb
 - spec/deployer_spec.rb
 - spec/group_spec.rb
@@ -164,10 +170,12 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: For lightweight puppet mastery. Organise multiple machines via rsync and
-  SSH rather than using puppet master
+summary: Provision using puppet and deploy your servers over SSH.
 test_files:
+- spec/app/after
 - spec/app/app.rb
+- spec/app/exclude.txt
+- spec/app/exclude/another.txt
 - spec/debloyer_spec.rb
 - spec/deployer_spec.rb
 - spec/group_spec.rb