tiller 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c984c96a5012b983e926379da35c40b3cb993918
+  data.tar.gz: 2cd4ae2955051ed74ec95721da45c2e7866b1641
+SHA512:
+  metadata.gz: 59028394e8ea01c10541d58c5f4896cbce8459210f2150017205280a6a9d811b9e471cd07b6d95051ded1c81bae1ae54ce304b23502a99d865159e43293878af
+  data.tar.gz: 05a6142da60107e38aa00120f166c051d0f82b9c72150e2b8a88a07041efad6776f4f4f68c8c04633f29b1b3760055fdb95be4bae3cee6e3d78f05987c3244af

data/bin/tiller

@@ -0,0 +1,138 @@
+#!/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!
+# Mark Round <github@markround.com>
+
+VERSION='0.0.2'
+
+require 'erb'
+require 'ostruct'
+require 'yaml'
+require 'fileutils'
+require 'pp'
+
+# This is needed so we can enumarate all the loaded plugins later
+class Class
+  def subclasses
+    ObjectSpace.each_object(Class).select { |c| c < self }
+  end
+end
+
+def warn_merge(key, old, new, type, source)
+  puts "Warning, merging duplicate #{type} values."
+  puts "#{key} => '#{old}' being replaced by : '#{new}' from #{source}"
+  new
+end
+
+module Tiller
+
+  # 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']
+  }
+
+  $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')))
+
+  puts "tiller v#{VERSION} (https://github.com/markround/tiller) <github@markround.com>"
+  puts "Using configuration from #{config[:tiller_base]}"
+  puts "Using plugins from #{config[:tiller_lib]}/tiller"
+  puts "Using environment #{config[:environment]}"
+
+  # Now load all our plugins
+  template_sources = Array.new
+  data_sources = Array.new
+  template_sources |= config[:common_config]['template_sources']
+  data_sources |= config[:common_config]['data_sources']
+  template_sources.each { |t| require "tiller/template/#{t}.rb" }
+  data_sources.each { |t| require "tiller/data/#{t}.rb" }
+
+  puts 'Template sources loaded ' + TemplateSource.subclasses.to_s
+  puts 'Data sources loaded ' + DataSource.subclasses.to_s
+
+  # Get all Templates for the given environment
+  templates = {}
+  TemplateSource.subclasses.each do |template_class|
+    ts = template_class.new(config)
+    ts.templates.each do |t|
+      templates[t]=ts.template(t)
+    end
+  end
+
+  puts "Templates to build #{templates.keys.to_s}"
+
+  # 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]}
+  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.
+  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.
+    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)
+      target_values.merge!(dc.target_values(template)) do |key, old, new|
+        warn_merge(key, old, new, 'target', data_class.to_s)
+      end
+    end
+
+    # Now, we build the 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.
+    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.
+    target_path = File.dirname(target_values['target'])
+    FileUtils.mkdir_p(target_path) if not 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
+      puts "Setting ownership/permissions on #{target_values['target']}"
+      FileUtils.chmod(target_values['perms'], target_values['target']) if target_values.has_key('perms')
+      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']}"
+    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."
+  puts "Calling #{config[:common_config]['exec']}..."
+  exec(config[:common_config]['exec'])
+
+end
+
+

data/examples/etc/tiller/common.yaml

@@ -0,0 +1,36 @@
+# Example configuration file, demonstrating how to use Tiller.
+#
+# These examples create two templates with different values depending on if you set the environment to
+# "production" or "staging".
+#
+# This would be called with the following environment variables set (e.g. from a bash prompt) :
+#
+# tiller_base=$PWD/examples/etc/tiller tiller_lib=$PWD/examples/lib tiller
+#
+# (Tiller uses the "production" environment if none is set). Or, for staging:
+#
+# environment=staging tiller_base=$PWD/examples/etc/tiller tiller_lib=$PWD/examples/lib tiller
+#
+# See the documentation for more details on how to use this in a Dockerfile.
+
+# exec: The executable to handover to after execution. In a Dockerfile, this would probably be /usr/bin/supervisord
+# Or some other daemon. For testing, /usr/bin/date (or similar) is a useful one-shot command that just exits,
+# so you can inspect your templates.
+exec: date
+
+# data_sources: Sources of data. Here, we're pulling in the provided FileDataSource (ships with this gem), and also the
+# NetworkDataSource under examples/lib/tiller. This is found because we set tiller_lib when we called the tiller
+# executable. We're not pulling in the example DummyDataSource, because it also provides target_values, so would
+# overwrite the target_values from FileDataSource - you should only have one DataSource providing this information,
+# otherwise your templates may end up in strange places you didn't expect!
+data_sources:
+  - file
+  - network
+
+
+# template_sources: Sources of templates, in priority order (first takes precendence). Again using the provided
+# FileTemplateSource (uses templates under <tiller_base>/templates), and also because we set tiller_lib, we can use
+# DummyTemplateSource which creates a single "dummy.erb" template.
+template_sources:
+  - file
+  - dummy

data/examples/etc/tiller/environments/production.yaml

@@ -0,0 +1,22 @@
+# Here is an example configuration file for your production environment.
+
+# First, we define the values for an example sensu_client template :
+sensu_client.erb:
+  target: /etc/sensu/conf.d/client.json
+  config:
+    sensu_host: 'sensu.example.com'
+    sensu_subscriptions:
+      - common
+      - physical
+      - mongo
+
+# This is a dummy template provided by the DummyTemplateSource. You'll notice that because we're not pulling in
+# DummyDataSource, the dummy_global variable is not set, but the template is still built without an error (the
+# value is just left blank).
+dummy.erb:
+  target: /tmp/files/dummy.txt
+  owner: root
+  group: wheel
+  perms: 0644
+  config:
+    dummy: 'Text from a filesource - production environment'

data/examples/etc/tiller/environments/staging.yaml

@@ -0,0 +1,24 @@
+# Here is an example configuration file for your staging environment.
+
+# First, we define the values for an example sensu_client template. In this example, we changed to including a "virtual"
+# subscription instead of "physical", which was set in the production environment.
+sensu_client.erb:
+  target: /etc/sensu/conf.d/client.json
+  config:
+    sensu_host: 'sensu.example.com'
+    sensu_subscriptions:
+      - common
+      - virtual
+      - mongo
+
+# This is a dummy template provided by the DummyTemplateSource. You'll notice that because we're not pulling in
+# DummyDataSource, the dummy_global variable is not set, but the template is still built without an error (the
+# value is just left blank). Here we also write the file to a different location that the one in the production
+# environment.
+dummy.erb:
+  target: /tmp/files/dummy-staging.txt
+  owner: root
+  group: wheel
+  perms: 0644
+  config:
+    dummy: 'Text from a filesource - staging environment'

data/examples/etc/tiller/templates/sensu_client.erb

@@ -0,0 +1,8 @@
+{
+    "client": {
+        "name": "<%= fqdn %>",
+        "address": "<%= ipv4_addresses[0][3] %>",
+        "subscriptions": <%= sensu_subscriptions %>,
+        "safe_mode": false
+    }
+}

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

@@ -0,0 +1,30 @@
+# 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 initialize(config)
+    super
+    @global_values = {
+        'dummy_global' => 'dummy global replacement text'
+    }
+  end
+
+  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.
+  def target_values(template_name)
+    {
+        'target'  => "/tmp/dummy/#{template_name}",
+        'user'    => 'root',
+        'group'   => 'root',
+        'perms'   => 0644
+    }
+  end
+
+end

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

@@ -0,0 +1,19 @@
+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.
+
+class NetworkDataSource < Tiller::DataSource
+
+  def initialize(config)
+    super
+    # Note, these rely on DNS being available and configured correctly!
+    @global_values = {
+        '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

@@ -0,0 +1,18 @@
+# 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"]
+  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 %>"
+  end
+
+end
+

data/lib/tiller/data/file.rb

@@ -0,0 +1,24 @@
+# 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'
+
+class FileDataSource < Tiller::DataSource
+
+  # We don't provide any global values, just ones specific to a template.
+  def initialize(config)
+    super
+    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[template_name]['config']
+  end
+
+  def target_values(template_name)
+    @config_hash[template_name]
+  end
+
+end

data/lib/tiller/datasource.rb

@@ -0,0 +1,39 @@
+# 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
+	class DataSource
+
+    # All subclasses get this, which is a hash containing tiller_base, tiller_lib and environment.
+    @@config = Array.new
+
+    def initialize(config)
+      @@config = config
+      @global_values = Hash.new
+    end
+
+    attr_reader :global_values
+
+    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'
+    #}
+    def target_values(template_name)
+      Hash.new
+    end
+
+    def ping
+      "ping!" + @@config.to_s
+    end
+
+	end
+end

data/lib/tiller/template/file.rb

@@ -0,0 +1,25 @@
+# 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/')
+  end
+
+  # 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 , '')
+    end
+  end
+
+  # Just open and return the file
+  def template(template_name)
+    open(File.join(@template_dir , template_name)).read
+  end
+
+end
+

data/lib/tiller/templatesource.rb

@@ -0,0 +1,26 @@
+# Tiller template source base class
+# Subclasses provide templates (an array), and individual template contents (a string containing ERB data)
+
+module Tiller
+	class TemplateSource
+
+    # All subclasses get this, which is a hash containing tiller_base, tiller_lib and environment.
+    @@config = Array.new
+
+    def initialize(config)
+      @@config = config
+    end
+
+    def templates
+      Hash.new
+    end
+
+    def template
+      String.new
+    end
+
+    def ping
+      "ping!" + @@config.to_s
+    end
+	end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: tiller
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Mark Round
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-18 00:00:00.000000000 Z
+dependencies: []
+description: A tool to create configuration files in Docker containers from a variety
+  of sources
+email: github@markround.com
+executables:
+- tiller
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/tiller
+- examples/etc/tiller/common.yaml
+- examples/etc/tiller/environments/production.yaml
+- examples/etc/tiller/environments/staging.yaml
+- examples/etc/tiller/templates/sensu_client.erb
+- examples/lib/tiller/data/dummy.rb
+- examples/lib/tiller/data/network.rb
+- examples/lib/tiller/template/dummy.rb
+- lib/tiller/data/file.rb
+- lib/tiller/datasource.rb
+- lib/tiller/template/file.rb
+- lib/tiller/templatesource.rb
+homepage: http://www.markround.com
+licenses:
+- MIT
+metadata:
+  source: https://github.com/markround/tiller
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Dynamic configuration generation for Docker
+test_files: []