tiller 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0faa026bbfbb368fe8d689c233cf79614e5dc9e1
-  data.tar.gz: 3f90927d1e6c1185fb41f70a7f543f11c36a04a0
+  metadata.gz: 86fc7d0cf3873002d5592553f0f5149cf252f09a
+  data.tar.gz: b1d175a16e5ed95836d026b2c031d850a909dcd2
 SHA512:
-  metadata.gz: 283636ada09058f6ecaa3c2ed1064f50d25a6354815eca4579e4d452663dcb1f576d34eb0d94f9c3f26a27866497d1aaadf64314530fcdfdcd4b1661d1dc9084
-  data.tar.gz: a7645f090d7eba2e112b83c2ea96996fda23e10fe5b95d7e4e9fd8fc9e601e6aebab2c8a83c7cd234a3cfc7fc6860450cb94cef9c6acc95df94a046f80617c70
+  metadata.gz: 7014d7b4591b1611c949c8a9096f02310ebac01fde5b5ec6410390456be54dcf9c46765f242954cc59d1262d8b9493bc8e776671fc337e195d669c79f09397a7
+  data.tar.gz: bc6d9b5e25f7844ff07ff5325d63623950fafe3eb57228109090d570844ebe9dbf84d4ad250db6417a65f17488ad1905c26f496d868f9ddfc552f9b06ef0f4fd

data/bin/tiller

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
 # Tiller - Dynamic configuration generator, intended for use in Dockerfiles
-# Named from the first ship-building (Docker) related term I could find that didn't have an existing gem named after it!
+# Named from the first ship-building (Docker) related term I could find that
+# didn't have an existing gem named after it!
 # Mark Round <github@markround.com>
 
-VERSION='0.1.0'
+VERSION = '0.1.2'
 
 require 'erb'
 require 'ostruct'
@@ -24,25 +25,26 @@ def warn_merge(key, old, new, type, source)
   new
 end
 
+# And we're on our way...
 module Tiller
-
-  # Set these two environment variables if you want to debug a configuration in a temporary directory.
+  # Set these two environment variables if you want to debug a configuration
+  # in a temporary directory.
   # EG: $ tiller_base=/tmp tiller_lib=/tmp/lib ./tiller
   config = {
-      :tiller_base  => (ENV['tiller_base'].nil?)  ? '/etc/tiller' : ENV['tiller_base'],
-      :tiller_lib   => (ENV['tiller_lib'].nil?)   ? '/usr/local/lib' : ENV['tiller_lib'],
-      # This is the main variable, usually the only one you pass into Docker.
-      :environment  => (ENV['environment'].nil?)  ? 'production' : ENV['environment']
+    :tiller_base  => (ENV['tiller_base'].nil?)  ? '/etc/tiller' : ENV['tiller_base'],
+    :tiller_lib   => (ENV['tiller_lib'].nil?)   ? '/usr/local/lib' : ENV['tiller_lib'],
+    # This is the main variable, usually the only one you pass into Docker.
+    :environment  => (ENV['environment'].nil?)  ? 'production' : ENV['environment']
   }
 
+  # Add tiller_lib to the LOAD PATH so we can pull in user-defined plugins
   $LOAD_PATH.unshift(config[:tiller_lib]) unless $LOAD_PATH.include?(config[:tiller_lib])
 
-  # User-provided sources.
   require 'tiller/templatesource.rb'
   require 'tiller/datasource.rb'
 
   # Load the common YAML configuration file
-  config[:common_config] = YAML::load(open(File.join(config[:tiller_base], 'common.yaml')))
+  config[:common_config] = YAML.load(open(File.join(config[:tiller_base], 'common.yaml')))
 
   puts "tiller v#{VERSION} (https://github.com/markround/tiller) <github@markround.com>"
   puts "Using configuration from #{config[:tiller_base]}"
@@ -61,83 +63,93 @@ module Tiller
   puts 'Data sources loaded ' + DataSource.subclasses.to_s
 
   # Get all Templates for the given environment
-  templates = {}
+  templates = Hash.new
   TemplateSource.subclasses.each do |template_class|
     ts = template_class.new(config)
     ts.templates.each do |t|
-      templates[t]=ts.template(t)
+      templates[t] = ts.template(t)
     end
   end
 
-  puts "Templates to build #{templates.keys.to_s}"
+  puts "Templates to build #{templates.keys}"
 
-  # Now go through all our data sources and start to assemble our "tiller_global" hash.
-  # As hashes are getting merged, new values will take precedence over older ones, and a warning will be displayed.
-  # Add in environment ti start with as it's very useful for all templates.
-  global_values = {'environment' => config[:environment]}
+  # Now go through all our data sources and start to assemble our global_values
+  # hash. As hashes are getting merged, new values will take precedence over
+  # older ones, and a warning will be displayed.
+  # We also add in 'environment' to start with as it's very useful for all
+  # templates.
+  global_values = { 'environment' => config[:environment] }
   DataSource.subclasses.each do |data_class|
     global_values.merge!(data_class.new(config).global_values) do |key, old, new|
       warn_merge(key, old, new, 'global', data_class.to_s)
     end
   end
 
-  # Now we go through each template we've identified, and get the values for each one.
+  # Now we go through each template we've identified, and get the
+  # values for each one.
   templates.each do |template, content|
     values = Hash.new
     target_values = Hash.new
-    puts "Building template #{template}"
 
-    # Now we populate the hash with values from each DataSource, warning if we get duplicate values.
+    # Now we populate the hash with values from each DataSource, warning if we
+    # get duplicate values.
     DataSource.subclasses.each do |data_class|
       dc = data_class.new(config)
       values.merge!(dc.values(template)) do |key, old, new|
         warn_merge(key, old, new, 'data', data_class.to_s)
       end
 
-      # Now get target_values (where the file should be installed to, permissions and so on)
+      # Now get target_values (where the file should be installed to,
+      # permissions and so on)
       target_values.merge!(dc.target_values(template)) do |key, old, new|
         warn_merge(key, old, new, 'target', data_class.to_s)
       end
     end
 
-    # If our data source returned no values (e.g. we don't build this template for this environment)
-    # We move onto the next one.
+    # If our data source returned no values (e.g. we don't build this template
+    # for this environment), we move onto the next one.
     next if target_values.empty?
 
     # Now, we build the template
+    puts "Building template #{template}"
     tiller = values.merge(global_values) do |key, old, new|
       warn_merge(key, old, new, 'global and local', 'merged configuration')
     end
 
-    # Use an OpenStruct namespace, as it's way easier than faffing around with manual binding, and also
-    # non-existing values just get replaced by <nil> instead of failing on errors.
+    # Use an OpenStruct namespace, as it's way easier than faffing around with
+    # manual binding, and also non-existing values just get replaced by <nil>
+    # instead of failing on errors.
     ns = OpenStruct.new(tiller)
     parsed_template = ERB.new(content).result(ns.instance_eval { binding })
 
-    # Write the template, and also create the directory path if it doesn't exist.
+    # Write the template, and also create the directory path if it
+    # doesn't exist.
     target_path = File.dirname(target_values['target'])
-    FileUtils.mkdir_p(target_path) if not File.directory?(target_path)
-    target = open(target_values['target'], "w")
+    FileUtils.mkdir_p(target_path) unless File.directory?(target_path)
+    target = open(target_values['target'], 'w')
     target.puts(parsed_template)
     target.close
 
     # Set permissions if we are running as root
-    if Process::Sys.geteuid == 0 then
+    if Process::Sys.geteuid == 0
       puts "Setting ownership/permissions on #{target_values['target']}"
-      FileUtils.chmod(target_values['perms'], target_values['target']) if target_values.has_key?('perms')
-      # Don't need to check for the presence of these, as they're ignored if null.
-      FileUtils.chown(target_values['user'], target_values['group'], target_values['target'])
+      if target_values.key?('perms')
+        FileUtils.chmod(target_values['perms'], target_values['target'])
+      end
+      # Don't need to check for the presence of these, as they're ignored
+      # if they are null.
+      FileUtils.chown(target_values['user'], target_values['group'],
+                      target_values['target'])
     else
-      puts "Not running as root, so not setting ownership/permissions on #{target_values['target']}"
+      puts 'Not running as root, so not setting ownership/permissions on ' \
+        "#{target_values['target']}"
     end
 
   end
 
-  # All templates created, so let's handover to the replacement process then it's home in time for tea and medals.
-  puts "Template generation completed, about to exec replacement process."
+  # All templates created, so let's handover to the replacement process then
+  # it's home in time for tea and medals.
+  puts 'Template generation completed, about to exec replacement process.'
   puts "Calling #{config[:common_config]['exec']}..."
   exec(config[:common_config]['exec'])
-
 end
-
-

data/examples/lib/tiller/data/dummy.rb

@@ -1,27 +1,25 @@
-# This is a "dummy" datasource for Tiller. All it does is provide a single global and local value,
-# And shows how you can provide a hash of target values to configure where templates are written.
-
+# This is a "dummy" datasource for Tiller. All it does is provide a single
+# global and local value, and shows how you can provide a hash of target values
+# to configure where templates are written.
 class DummyDataSource < Tiller::DataSource
-
   def global_values
     { 'dummy_global' => 'dummy global replacement text' }
   end
 
-  def values(template_name)
+  def values(_template_name)
     { 'dummy' => 'dummy replacement text' }
   end
 
-  # Dummy values, useful for testing. Will just result in the template being built and written to /tmp/dummy.
-  # Remember that perms must be in octal (no quotes).
-  # Note that as you have the environment name in the @@config hash, you can always return different values
-  # for different environments.
+  # Dummy values, useful for testing. Will just result in the template being
+  # built and written to /tmp/dummy. Remember that perms must be in octal
+  # (no quotes). Note that as you have the environment name in the @config hash,
+  # you can always return different values for different environments.
   def target_values(template_name)
     {
-        'target'  => "/tmp/dummy/#{template_name}",
-        'user'    => 'root',
-        'group'   => 'root',
-        'perms'   => 0644
+      'target'  => "/tmp/dummy/#{template_name}",
+      'user'    => 'root',
+      'group'   => 'root',
+      'perms'   => 0644
     }
   end
-
 end

data/examples/lib/tiller/data/network.rb

@@ -1,17 +1,15 @@
 require 'socket'
-
-# This is a quick example of a global datasource for Tiller. It shows how you might provide some basic
-# network-related information to your templates. It's a super quick and hacky, but serves as a useful example.
-# You can then do things like <%= fqdn %> or <%= ipv4_addresses[0][3] %> in your templates.
-
+# This is a quick example of a global datasource for Tiller.
+# It shows how you might provide some basic network-related information to your
+# templates. It's a super quick and hacky, but serves as a useful example.
+# You can then do things like <%= fqdn %> or <%= ipv4_addresses[0][3] %> in
+# your templates.
 class NetworkDataSource < Tiller::DataSource
-
   def global_values
     # Note, these rely on DNS being available and configured correctly!
     {
-        'fqdn'            =>  Socket.gethostbyname(Socket.gethostname).first,
-        'ipv4_addresses'  =>  Socket.getaddrinfo(Socket.gethostbyname(Socket.gethostname).first, nil, :INET)
+      'fqdn'            =>  Socket.gethostbyname(Socket.gethostname).first,
+      'ipv4_addresses'  =>  Socket.getaddrinfo(Socket.gethostbyname(Socket.gethostname).first, nil, :INET)
     }
   end
-
 end

data/examples/lib/tiller/template/dummy.rb

@@ -1,18 +1,15 @@
 # This is another quick example of how to create a template source.
-
 class DummyTemplateSource < Tiller::TemplateSource
-
   # Just provide a single dummy template
   def templates
-    ["dummy.erb"]
+    ['dummy.erb']
   end
 
   # And return some sample ERB content.
-  # Note that as you have the environment name in the @@config hash, you can always return different templates
-  # for different environments.
-  def template(template_name)
-    "This is a dummy template! <%= dummy %> \n Here is a global value <%= dummy_global %>"
+  # Note that as you have the environment name in the @config hash, you can
+  # always return different templates for different environments.
+  def template(_template_name)
+    "This is a dummy template! <%= dummy %> \n "\
+    'Here is a global value <%= dummy_global %>'
   end
-
 end
-

data/lib/tiller/data/environment.rb

@@ -1,12 +1,10 @@
-# Environment datasource for Tiller. This extracts all environment variables, and makes them available to templates
-# by converting to lowercase and preceeding them with env_. E.G. env_home, env_logname and so on.
-
+# Environment datasource for Tiller. This extracts all environment variables,
+# and makes them available to templates by converting to lowercase and
+# preceeding them with env_. E.G. env_home, env_logname and so on.
 class EnvironmentDataSource < Tiller::DataSource
-
   def global_values
     values = Hash.new
-    ENV.each { |k,v| values["env_#{k.downcase}"] = v }
+    ENV.each { |k, v| values["env_#{k.downcase}"] = v }
     values
   end
-
 end

data/lib/tiller/data/file.rb

@@ -1,26 +1,23 @@
-# File datasource for Tiller. This works the same way as the default behaviour in Runner.rb - it loads your
-# <environment>.yaml file and provides data from it. See examples/etc/tiller/environments/production.yaml to see
-# what this file looks like.
+require 'yaml'
+# File datasource for Tiller. This works the same way as the default behaviour
+# in Runner.rb - it loads your <environment>.yaml file and pulls data from it.
+# See examples/etc/tiller/environments/production.yaml to see what this file
+# looks like.
 #
 # We also don't provide any global values, just ones specific to a template.
-
-
-require 'yaml'
-
 class FileDataSource < Tiller::DataSource
-
   # Open and parse the environment file
   def setup
-    env_file = File.join(@@config[:tiller_base], "environments", "#{@@config[:environment]}.yaml")
-    @config_hash = YAML::load(open(env_file))
+    env_file = File.join(@config[:tiller_base], 'environments',
+                         "#{@config[:environment]}.yaml")
+    @config_hash = YAML.load(open(env_file))
   end
 
   def values(template_name)
-    @config_hash.has_key?(template_name) ? @config_hash[template_name]['config'] : Hash.new
+    @config_hash.key?(template_name) ? @config_hash[template_name]['config'] : Hash.new
   end
 
   def target_values(template_name)
-    @config_hash.has_key?(template_name) ? @config_hash[template_name] : Hash.new
+    @config_hash.key?(template_name) ? @config_hash[template_name] : Hash.new
   end
-
 end

data/lib/tiller/data/random.rb

@@ -1,20 +1,17 @@
-# Random datasource for Tiller. Provides Base64, UUID and other useful random strings
-
 require 'securerandom'
-
+# Random datasource for Tiller. Provides Base64, UUID and other useful
+# random strings.
 class RandomDataSource < Tiller::DataSource
-
   def global_values
     {
-        'random_base64' => SecureRandom.base64,
-        'random_hex' => SecureRandom.hex,
-        'random_bytes' => SecureRandom.random_bytes,
-        'random_number_10' => SecureRandom.random_number(10),
-        'random_number_100' => SecureRandom.random_number(100),
-        'random_number_1000' => SecureRandom.random_number(1000),
-        'random_urlsafe_base64' => SecureRandom.urlsafe_base64,
-        'random_uuid' => SecureRandom.uuid
+      'random_base64' => SecureRandom.base64,
+      'random_hex' => SecureRandom.hex,
+      'random_bytes' => SecureRandom.random_bytes,
+      'random_number_10' => SecureRandom.random_number(10),
+      'random_number_100' => SecureRandom.random_number(100),
+      'random_number_1000' => SecureRandom.random_number(1000),
+      'random_urlsafe_base64' => SecureRandom.urlsafe_base64,
+      'random_uuid' => SecureRandom.uuid
     }
   end
-
 end

data/lib/tiller/datasource.rb

@@ -1,20 +1,20 @@
 # Tiller data source base class.
-#
-# Subclasses provide global_values and/or values (things local to a specific template) and target_values (meta data
-# about a template, e.g. target location, permissions, owner and so on)
-
 module Tiller
+  # Subclasses provide global_values and/or values (things local to a specific
+  # template) and target_values (meta data about a template, e.g. target
+  # location, permissions, owner and so on)
   class DataSource
-
-    # All subclasses get this, which is a hash containing tiller_base, tiller_lib and environment.
-    @@config = Array.new
+    # All subclasses get this, which is a hash containing tiller_base,
+    # tiller_lib and environment.
+    @config = Array.new
 
     def initialize(config)
-      @@config = config
-      self.setup
+      @config = config
+      setup
     end
 
-    # This is where any post-initialisation logic happens (connecting to a database etc.)
+    # This is where any post-initialisation logic happens
+    # (connecting to a database etc.)
     def setup
     end
 
@@ -22,26 +22,27 @@ module Tiller
       Hash.new
     end
 
-    # We should always return a hash; if we have no data for the given template, just return an empty hash.
-    def values(template_name)
+    # We should always return a hash; if we have no data for the given
+    # template, just return an empty hash.
+    def values(_template_name)
       Hash.new
     end
 
     # This should provide a hash similar to this example :
-    #{
+    # {
     #    'target'  => "/tmp/#{template_name}",
     #    'user'    => 'root',
     #    'group'   => 'root',
     #    'perms'   => '0644'
-    #}
-    # Again, we should always return a hash; if we have no data for the given template, just return an empty hash.
-    def target_values(template_name)
+    # }
+    # Again, we should always return a hash; if we have no data for the given
+    # template, just return an empty hash.
+    def target_values(_template_name)
       Hash.new
     end
 
     def ping
-      "ping!" + @@config.to_s
+      'ping!' + @config.to_s
     end
-
   end
 end

data/lib/tiller/template/file.rb

@@ -1,15 +1,14 @@
-# File template datasource for Tiller. This works the same way that Runner.rb used to - it returns templates files
-# present under /etc/tiller/templates (or wherever the tiller_base environment is set).
-
+# File template datasource for Tiller. This works the same way that Runner.rb
+# used to - it returns templates files present under /etc/tiller/templates
+# (or wherever the tiller_base environment is set).
 class FileTemplateSource < Tiller::TemplateSource
-
   def initialize(config)
     super
-    @template_dir = File.join(@@config[:tiller_base], 'templates/')
+    @template_dir = File.join(@config[:tiller_base], 'templates/')
   end
 
-  # Simply return a list of all the templates in the $tiller_base/templates directory
-  # With the preceeding directory path stripped off
+  # Simply return a list of all the templates in the $tiller_base/templates
+  # directory with the preceeding directory path stripped off
   def templates
     Dir.glob(File.join(@template_dir, '**', '*.erb')).each do |t|
       t.sub!(@template_dir, '')
@@ -20,6 +19,4 @@ class FileTemplateSource < Tiller::TemplateSource
   def template(template_name)
     open(File.join(@template_dir, template_name)).read
   end
-
 end
-

data/lib/tiller/templatesource.rb

@@ -1,17 +1,18 @@
 # Tiller template source base class
-# Subclasses provide templates (an array), and individual template contents (a string containing ERB data)
-
 module Tiller
+  # Subclasses provide templates (an array), and individual template contents
+  # (a string containing ERB data)
   class TemplateSource
-
-    # All subclasses get this, which is a hash containing tiller_base, tiller_lib and environment.
-    @@config = Array.new
+    # All subclasses get this, which is a hash containing tiller_base,
+    # tiller_lib and environment.
+    @config = Array.new
 
     def initialize(config)
-      @@config = config
+      @config = config
     end
 
-    # This is where any post-initialisation logic happens (connecting to a database etc.)
+    # This is where any post-initialisation logic happens
+    # (connecting to a database etc.)
     def setup
     end
 
@@ -24,7 +25,7 @@ module Tiller
     end
 
     def ping
-      "ping!" + @@config.to_s
+      'ping!' + @config.to_s
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tiller
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Mark Round
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-08 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies: []
 description: A tool to create configuration files in Docker containers from a variety
   of sources. See https://github.com/markround/tiller for examples and documentation.