devstructure 0.3.0 → 0.3.1

data/lib/devstructure/blueprint.rb

@@ -176,7 +176,7 @@ EOF
         return if manager == package
         io.printf "#{command}\n", package, version
         if "apt" == manager && package =~ /^rubygems(\d+\.\d+(?:\.\d+)?)$/
-          io.puts "/usr/bin/gem#{$1} install rubygems-update"
+          io.puts "/usr/bin/gem#{$1} install --no-rdoc --no-ri rubygems-update"
           io.puts "/usr/bin/ruby#{$1} $(PATH=\"$PATH:/var/lib/gems/#{
             $1}/bin\" which update_rubygems)"
         end
@@ -187,25 +187,35 @@ EOF
     # and heredoc syntax.  Binary files are written using `base64`(1) and
     # symbolic links are placed using `ln`(1).  Shocking stuff.
     files.sort.each do |pathname, content|
-      if Hash == content.class
+      io.puts "mkdir -p #{File.dirname(pathname)}"
+      owner = group = mode = nil
+      command = "cat"
+      if Hash === content
+        owner = content["_owner"]
+        group = content["_group"]
         if content["_target"]
           io.puts "ln -s #{content["_target"]} #{pathname}"
           next
-        elsif content["_base64"]
-          content = content["_base64"]
-          command = "base64 --decode"
+        else
+          mode = content["_mode"]
+          if content["_base64"]
+            content = content["_base64"]
+            command = "base64 --decode"
+          else
+            content = content["_content"]
+          end
         end
-      else
-        content.gsub!(/\\/, "\\\\\\\\")
-        content.gsub!(/\$/, "\\$")
-        command = "cat"
       end
+      content.gsub!(/\\/, "\\\\\\\\")
+      content.gsub!(/\$/, "\\$")
       eof = "EOF"
       eof << "EOF" while content =~ /^#{eof}$/
-      io.puts "mkdir -p #{File.dirname(pathname)}"
       io.puts "#{command} >#{pathname} <<#{eof}"
       io.puts content
       io.puts eof
+      io.puts "chown #{owner} #{pathname}" if owner
+      io.puts "chgrp #{group} #{pathname}" if group
+      io.puts "chmod #{mode} #{pathname}" if mode
     end if files
 
     # Source tarballs are downloaded, extracted, and removed.  Generally,
@@ -231,7 +241,7 @@ EOF
 
     # We need a pre-built map of each manager to its own manager so we can
     # easily declare dependencies within the Puppet manifest tree.
-    managers = {}
+    managers = {"apt" => nil}
     walk(:package => lambda { |manager, command, package, version|
       managers[package] = manager if packages[package] && manager != package
     })
@@ -277,7 +287,7 @@ EOF
                 :provider => :gem,
                 :ensure => :latest
               )
-              Puppet::Package["rubygems1.8"]
+              Puppet::Package["rubygems-update"]
             else
               manifest[manager] << Puppet::Exec.new(
                 "/usr/bin/gem#{v} install --no-rdoc --no-ri rubygems-update",
@@ -287,8 +297,8 @@ EOF
               Puppet::Exec["rubygems-update-#{v}"]
             end
             manifest[manager] << Puppet::Exec.new(
-              "/usr/bin/ruby#{v} /usr/bin/update_rubygems",
-              :path => %W(/usr/bin /var/lib/gems/#{v}/bin),
+              "/bin/sh -c '/usr/bin/ruby#{v} $(PATH=$PATH:/var/lib/gems/#{
+                v}/bin which update_rubygems)'",
               :require => prereq
             )
           end
@@ -354,35 +364,55 @@ EOF
     #
     # File content is handled much like the shell version except base 64
     # decoding takes place here in Ruby rather than in the `base64`(1)
-    # tool.  Resources for all parent directories are created ahead of
-    # any file.  Puppet's autorequire mechanism will ensure that a file's
-    # parent directories are realized before the file itself.
+    # tool.
     if files && 0 < files.length
-      manifest << Puppet::Package.defaults(
-        :before => files.sort.map { |pathname, content|
-          Puppet::File[pathname]
-        }
-      )
+      classes = managers.keys.
+        reject { |manager| 0 == packages[manager]["_packages"].length }.
+        map { |manager| Puppet::Class[manager] }
+      if 0 < classes.length
+        manifest << Puppet::File.defaults(:require => classes)
+      end
       files.sort.each do |pathname, content|
+
+        # Resources for all parent directories are created ahead of
+        # any file.  Puppet's autorequire mechanism will ensure that a
+        # file's parent directories are realized before the file itself.
         dirnames = File.dirname(pathname).split("/")
         dirnames.shift
         (0..(dirnames.length - 1)).each do |i|
           manifest << Puppet::File.new("/#{dirnames[0..i].join("/")}",
             :ensure => :directory)
         end
-        if Hash == content.class
+
+        # Convert the blueprint file attributes to those that Puppet
+        # understands.  Everything's optional.
+        options = {}
+        if Hash === content
+          options[:owner] = content["_owner"] if content["_owner"]
+          options[:group] = content["_group"] if content["_group"]
           if content["_target"]
-            manifest << Puppet::File.new(pathname,
-              :ensure => content["_target"])
-            next
-          elsif content["_base64"]
-            content = Base64.decode64(content["_base64"])
+            options[:ensure] = content["_target"]
+          else
+            options[:mode] = content["_mode"] if content["_mode"]
+            options[:ensure] = :file
+            options[:content] = if content["_base64"]
+              Base64.decode64(content["_base64"])
+            else
+              content["_content"]
+            end
           end
+
+        # The easiest way to specify a file is to include just the
+        # content.  The owner and group will be `root` and the mode will
+        # be set according to the `umask`.
+        else
+          options = {
+            :content => content,
+            :ensure => :file,
+          }
         end
-        manifest << Puppet::File.new(pathname,
-          :content => content,
-          :ensure => :file
-        )
+
+        manifest << Puppet::File.new(pathname, options)
       end
     end
 
@@ -391,11 +421,6 @@ EOF
     # such as this in a shell invocation.  This is a pretty direct Puppet
     # equivalent to the shell version above.
     if sources && 0 < sources.length
-      manifest << Puppet::Package.defaults(
-        :before => sources.sort.map { |dirname, filename|
-          Puppet::Exec[pathname]
-        }
-      )
       sources.sort.each do |dirname, filename|
         manifest << Puppet::Exec.new(filename,
           :command => "/bin/sh -c 'wget http://s3.amazonaws.com/blueprint-sources/#{filename}; tar xf #{filename}; rm #{filename}'",
@@ -473,22 +498,30 @@ EOF
         :mode => "755",
         :owner => "root",
         :recursive => true
-      if Hash == content.class
+      owner = group = mode = nil
+      if Hash === content
+        owner = content["_owner"]
+        group = content["_group"]
         if content["_target"]
           cookbook.link pathname,
-            :group => "root",
-            :owner => "root",
+            :group => group || "root",
+            :owner => owner || "root",
             :to => content["_target"]
           next
-        elsif content["_base64"]
-          content = content["_base64"]
+        else
+          mode = content["_mode"]
+          if content["_base64"]
+            content = content["_base64"]
+          else
+            content = content["_content"]
+          end
         end
       end
       cookbook.cookbook_file pathname, content,
         :backup => false,
-        :group => "root",
-        :mode => "644",
-        :owner => "root",
+        :group => group || "root",
+        :mode => mode || "644",
+        :owner => owner || "root",
         :source => pathname[1..-1]
     end if files
 

data/lib/devstructure/puppet.rb

@@ -14,13 +14,18 @@
 # [sandbox-blueprint]: http://devstructure.github.com/contractor/sandbox-blueprint.1.html
 require 'devstructure'
 
-# Make `Symbol`s `Comparable` so we can sort each list of resource
+# Make `Symbol`s and `nil`s `Comparable` so we can sort each list of resource
 # attributes before converting to a string.
 class Symbol
   def <=>(other)
     to_s <=> other.to_s
   end
 end
+class NilClass
+  def <=>(other)
+    other.nil? ? 0 : 1
+  end
+end
 
 module DevStructure::Puppet
 
@@ -48,19 +53,31 @@ module DevStructure::Puppet
     end
 
     # Add a resource to this manifest.  Order is never important in Puppet
-    # since all dependencies must be declared.
+    # since all dependencies must be declared.  Normal resources that have
+    # names are just added to the tree.  Resources that are declaring
+    # defaults for an entire type have `nil` names so they behave more
+    # cumulatively.
     def <<(resource)
       @resources[resource.type] ||= {}
-      @resources[resource.type][resource.name] = resource
+      if resource.name
+        @resources[resource.type][resource.name] = resource
+      elsif @resources[resource.type][resource.name]
+        @resources[resource.type][resource.name].merge!(resource)
+      else
+        @resources[resource.type][resource.name] = resource
+      end
     end
 
     # Turn this manifest into a Puppet class.  We start with a base level
     # of indentation that we carry through our resources and manifests.
     # Order is again not important so we don't make much effort.  The
     # Puppet grammar prohibits dots in class names so we replace `.` with
-    # `--`.  Resources are grouped by type to reduce the total number of
-    # lines required.  If this manifest has a parent, the last thing we
-    # do is include ourselves in the parent.
+    # `--`.
+    #
+    # Defaults for the entire type are handled first.  Normal resources
+    # are grouped by type to reduce the total number of lines required.
+    # If this manifest has a parent, the last thing we do is include
+    # ourselves in the parent.
     def to_s(tab="")
       out = []
       out << "#{tab}class #{@name.gsub(".", "--")} {"
@@ -68,6 +85,9 @@ module DevStructure::Puppet
         out << manifest.to_s("#{tab}\t")
       end
       @resources.sort.each do |type, resources|
+        if resource = resources.delete(nil)
+          out << resource.to_s("#{tab}\t")
+        end
         if 1 < resources.length
           out << "#{tab}\t#{type} {"
           resources.sort.each do |name, resource|
@@ -75,7 +95,7 @@ module DevStructure::Puppet
             out << resource.to_s("#{tab}\t")
           end
           out << "#{tab}\t}"
-        else
+        elsif 1 == resources.length
           out << resources.values.first.to_s("#{tab}\t")
         end
       end
@@ -100,7 +120,7 @@ module DevStructure::Puppet
       clear
       options.each { |k, v| self[k.to_s] = v }
       @type = self.class.to_s.downcase[/[^:]+$/]
-      @name = name.to_s.downcase
+      @name = name && name.to_s
       @style = :complete
     end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: devstructure
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Richard Crowley
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-01 00:00:00 +00:00
+date: 2010-09-02 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency