Class: Chef::Cookbook

Inherits:
Object
  • Object
show all
Defined in:
lib/devstructure/chef.rb

Overview

A cookbook is a collection of Chef resources plus the files and other supporting objects needed to run it.

Instance Method Summary collapse

Constructor Details

#initialize(name, comment, options = {}) ⇒ Cookbook

The name and options given to a cookbook become the filename and the parameters set in metadata.rb. The comment is a bit awkward and exists so the disclaimer supplied with all blueprints can be shown at the top of metadata.rb.



29
30
31
32
 
# File 'lib/devstructure/chef.rb', line 29

def initialize(name, comment, options={})
  @name, @comment, @options = name, comment, options
  @resources, @files = [], {}
end

Instance Method Details

#<<(resource) ⇒ Object

Resources should be added in the order they’re required to run. That is how Chef manages dependencies.



36
37
38
 
# File 'lib/devstructure/chef.rb', line 36

def <<(resource)
  @resources << resource
end

#apt_package(name, options = {}) ⇒ Object

In Chef, there are lots of top-level helpers for creating resources. This selection of almost-API-alikes facilitates the same thing for a DevStructure::Chef::Cookbook.



43
44
45
 
# File 'lib/devstructure/chef.rb', line 43

def apt_package(name, options={})
  self << Chef::Resource.new(:apt_package, name, options)
end

#cookbook_file(name, content, options = {}) ⇒ Object 



58
59
60
61
 
# File 'lib/devstructure/chef.rb', line 58

def cookbook_file(name, content, options={})
  self << Chef::Resource.new(:cookbook_file, name, options)
  @files[name] = content
end

#directory(name, options = {}) ⇒ Object 



52
53
54
 
# File 'lib/devstructure/chef.rb', line 52

def directory(name, options={})
  self << Chef::Resource.new(:directory, name, options)
end

#execute(name, options = {}) ⇒ Object 



49
50
51
 
# File 'lib/devstructure/chef.rb', line 49

def execute(name, options={})
  self << Chef::Resource.new(:execute, name, options)
end

#gem_package(name, options = {}) ⇒ Object 



46
47
48
 
# File 'lib/devstructure/chef.rb', line 46

def gem_package(name, options={})
  self << Chef::Resource.new(:gem_package, name, options)
end

#link(name, options = {}) ⇒ Object 



55
56
57
 
# File 'lib/devstructure/chef.rb', line 55

def link(name, options={})
  self << Chef::Resource.new(:link, name, options)
end

#to_gz(io) ⇒ Object

This is where the magic happens. The generated Chef cookbook will come as a tarball, written into whatever IO-like object is passed here. The DevStructure website will pass StringIO while the command-line tools will pass File.



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/devstructure/chef.rb', line 67

def to_gz(io)
  mtime = Time.now
  gz = Zlib::GzipWriter.new(io)
  tar = Archive::Tar::Minitar::Writer.new(gz)
  tar.mkdir @name, :mode => 0755, :mtime => mtime

  # `metadata.rb` contains the typical DevStructure comment, a
  # declaration of support for Ubuntu 10.04 or better, and any other
  # metadata passed to the constructor of this `Cookbook`.
  @options[:supports] ||= ["ubuntu", ">= 10.04"]
  metadata = ([@comment] + @options.sort.collect do |key, value|
    "#{key} #{[value].flatten.collect { |v| v.inspect }.join(", ")}\n"
  end).join("")
  tar.add_file_simple("#{@name}/metadata.rb", {
    :mode => 0644,
    :size => metadata.length,
    :mtime => mtime
  }) { |w| w.write metadata }

  # Build the recipe.  Each resource handles its own stringification so
  # the work done here amounts to gathering up a string and placing it
  # in a file in the tarball.
  resources = @resources.collect { |resource| resource.to_s }.join("")
  tar.mkdir "#{@name}/recipes", :mode => 0755, :mtime => mtime
  tar.add_file_simple("#{@name}/recipes/default.rb", {
    :mode => 0644,
    :size => resources.length,
    :mtime => mtime
  }) { |w| w.write resources }

  # Include any files referenced by `cookbook_file` resources.  They
  # all appear in `files/default/` as if that is the root of the
  # filesystem.
  if 0 < @files.length
    tar.mkdir "#{@name}/files", :mode => 0755, :mtime => mtime
    tar.mkdir "#{@name}/files/default", :mode => 0755, :mtime => mtime
    @files.each do |pathname, content|
      dirnames = File.dirname(pathname).split("/")
      dirnames.shift
      (0..(dirnames.length - 1)).each do |i|
        tar.mkdir "#{@name}/files/default/#{dirnames[0..i].join("/")}",
          :mode => 0755, :mtime => mtime
      end
      tar.add_file_simple("#{@name}/files/default#{pathname}", {
        :mode => 0644,
        :size => content.length,
        :mtime => mtime
      }) { |w| w.write content }
    end
  end

  # Return the finalized tarball.
  tar.close
  gz.close
  io

end