tiller 0.7.10 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87543dcddd7ffe3367e1917fccedb35065d13f56
-  data.tar.gz: 26180fa0c8340cfaf5dc257f8b4bab72119eebc5
+  metadata.gz: acd35e1f4954ea1c60fd5c27ea63f44fe7400eba
+  data.tar.gz: 2ec16005714189cbad10709a98a742f35fa944a4
 SHA512:
-  metadata.gz: 807408260d5299ab564fba2d7f84f255eb51de4a060e95203c9dbccc09c923c031fcc135c8f856bb29b4a3ec5abe5bacf06bd8601dca3301d10ff831b9e19bc1
-  data.tar.gz: ec485ee8ecc83048a7e769c42b8dd308a4125aa4686cc72e0c3dc21942d73745abea01e9679a058d176274b04775941fe496018ce9333521a1bdc7037796db11
+  metadata.gz: 0987e16d81c94e21d111a35c3241a4522cad991cbcbf65818be9966a9f82f0f3b2940ecb71f11a739dd515cbaebae1536985e85520eef31ec2efe7f0c173356b
+  data.tar.gz: 6471f8c24b1465510fb800f2ce3fc22a281ecbc2e13ea8aef968090397ee782473a2ee0bed58a3d2dc7ceea2ce790de4bc25d0147f6ac192b998c39e946fdf39

data/bin/tiller

@@ -8,7 +8,7 @@
 #
 # Mark Dastmalchi-Round <github@markround.com>
 
-VERSION = '0.7.10'
+VERSION = '0.8.0'
 
 require 'erb'
 require 'ostruct'
@@ -27,6 +27,7 @@ require 'tiller/templatesource'
 require 'tiller/datasource'
 require 'tiller/logger'
 require 'digest/md5'
+require 'tiller/render'
 
 EXIT_SUCCESS = 0
 
@@ -35,11 +36,14 @@ module Tiller
 
   puts "tiller v#{VERSION} (https://github.com/markround/tiller) <github@markround.com>"
 
-  config = parse_options(Tiller::Defaults)
-  log = Tiller::Logger.new(config)
+  class << self;
+    attr_accessor :config, :log, :templates, :tiller
+  end
 
-  log.debug("Executable: #{__FILE__}")
+  Tiller::config = parse_options(Tiller::Defaults)
+  Tiller::log = Tiller::Logger.new
 
+  log.debug("Executable: #{__FILE__}")
 
   # 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])
@@ -73,6 +77,10 @@ module Tiller
 
   log.info('Template sources loaded ' + template_classes.to_s)
   log.info('Data sources loaded ' + data_classes.to_s)
+  if (config.key?('helpers'))
+    helper_modules    = helper_loader(config['helpers'])
+    log.info('Helper modules loaded ' + helper_modules.to_s)
+  end
 
   # 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
@@ -85,19 +93,19 @@ module Tiller
     # e.g. environment-specific execs and so on. We do this first so that connection strings
     # to datasources (e.g. zookeeper) can be included in the config before we obtain any
     # values.
-    config.merge!(data_class.new(config).common) do |key, old, new|
+    config.merge!(data_class.new.common) do |key, old, new|
       warn_merge(key, old, new, 'common', data_class.to_s)
     end
 
-    global_values.merge!(data_class.new(config).global_values) do |key, old, new|
+    global_values.merge!(data_class.new.global_values) do |key, old, new|
       warn_merge(key, old, new, 'global', data_class.to_s)
     end
   end
 
   # Get all Templates for the given environment
-  templates = {}
+  Tiller::templates = {}
   template_classes.each do |template_class|
-    ts = template_class.new(config)
+    ts = template_class.new
     ts.templates.each do |t|
       templates[t] = ts.template(t)
     end
@@ -114,13 +122,13 @@ module Tiller
   templates.each do |template, content|
 
     # Start with a hash of our global values
-    tiller = Hash.new.merge(global_values)
+    Tiller::  tiller = Hash.new.merge(global_values)
     target_values = {}
 
     # Now we add to the 'tiller' hash with values from each DataSource, warning if we
     # get duplicate values.
     data_classes.each do |data_class|
-      dc = data_class.new(config)
+      dc = data_class.new
       if dc.values(template) != nil
         tiller.merge!(dc.values(template)) do |key, old, new|
           warn_merge(key, old, new, 'data', data_class.to_s)
@@ -141,11 +149,8 @@ module Tiller
     # Now, we build the template
     log.info("Building template #{template}")
 
-    # 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, nil, '-').result(ns.instance_eval { binding })
+    # Use our re-usable render tag
+    parsed_template = Tiller::render(template)
 
     # Write the template, and also create the directory path if it
     # doesn't exist.

data/lib/tiller/consul.rb

@@ -7,19 +7,19 @@ module Tiller::ConsulCommon
   def setup
     # Set our defaults if not specified
     @consul_config = Tiller::Consul.defaults
-    raise 'No Consul configuration block' unless @config.has_key?('consul')
-    @consul_config.deep_merge!(@config['consul'])
+    raise 'No Consul configuration block' unless Tiller::config.has_key?('consul')
+    @consul_config.deep_merge!(Tiller::config['consul'])
 
     # Sanity check
     ['url'].each {|c| raise "Consul: Missing Consul configuration #{c}" unless @consul_config.has_key?(c)}
 
     # Now we connect to Consul
     Diplomat.configure do |config|
-      @log.debug("#{self} : Connecting to Consul at #{@consul_config['url']}")
+      Tiller::log.debug("#{self} : Connecting to Consul at #{@consul_config['url']}")
       config.url = @consul_config['url']
 
       if @consul_config['acl_token']
-        @log.debug("#{self} : Using Consul ACL token")
+        Tiller::log.debug("#{self} : Using Consul ACL token")
         config.acl_token = @consul_config['acl_token']
       end
     end
@@ -27,7 +27,7 @@ module Tiller::ConsulCommon
 
   # Interpolate configuration placeholders with values
   def interpolate(path, template_name = nil)
-    path.gsub!('%e', @config[:environment])
+    path.gsub!('%e', Tiller::config[:environment])
     path.gsub!('%t', template_name) if template_name
     path
   end

data/lib/tiller/data/consul.rb

@@ -10,21 +10,21 @@ class ConsulDataSource < Tiller::DataSource
   def global_values
     # Fetch globals
     path = interpolate("#{@consul_config['values']['global']}")
-    @log.debug("#{self} : Fetching globals from #{path}")
+    Tiller::log.debug("#{self} : Fetching globals from #{path}")
     globals = fetch_all_keys(path)
 
     # Do we have per-env globals ? If so, merge them
     path = interpolate("#{@consul_config['values']['per_env']}")
-    @log.debug("#{self} : Fetching per-environment globals from #{path}")
+    Tiller::log.debug("#{self} : Fetching per-environment globals from #{path}")
     globals.deep_merge!(fetch_all_keys(path))
 
     # Do we want to register services in consul_services hash ?
     if @consul_config['register_services']
-      @log.debug("#{self} : Registering Consul services")
+      Tiller::log.debug("#{self} : Registering Consul services")
       globals['consul_services'] = {}
       services = Diplomat::Service.get_all({ :dc => @consul_config['dc'] })
       services.marshal_dump.each do |service, _data|
-        @log.debug("#{self} : Fetching Consul service information for #{service}")
+        Tiller::log.debug("#{self} : Fetching Consul service information for #{service}")
         service_data = Diplomat::Service.get(service, :all, { :dc => @consul_config['dc']})
         globals['consul_services'].merge!( { "#{service}" => service_data })
       end
@@ -32,7 +32,7 @@ class ConsulDataSource < Tiller::DataSource
 
     # Do we want to register nodes in consul_nodes hash ?
     if @consul_config['register_nodes']
-      @log.debug("#{self} : Registering Consul nodes")
+      Tiller::log.debug("#{self} : Registering Consul nodes")
       globals['consul_nodes'] = {}
       nodes = Diplomat::Node.get_all
       nodes.each do |n|
@@ -44,13 +44,13 @@ class ConsulDataSource < Tiller::DataSource
 
   def values(template_name)
     path = interpolate("#{@consul_config['values']['template']}", template_name)
-    @log.debug("#{self} : Fetching template values from #{path}")
+    Tiller::log.debug("#{self} : Fetching template values from #{path}")
     fetch_all_keys(path)
   end
 
   def target_values(template_name)
     path = interpolate("#{@consul_config['values']['target']}", template_name)
-    @log.debug("#{self} : Fetching template target values from #{path}")
+    Tiller::log.debug("#{self} : Fetching template target values from #{path}")
     fetch_all_keys(path)
   end
 
@@ -60,7 +60,7 @@ class ConsulDataSource < Tiller::DataSource
     all_keys = {}
     if keys.is_a? Array
       keys.each do |k|
-        @log.debug("#{self} : Fetching key #{k}")
+        Tiller::log.debug("#{self} : Fetching key #{k}")
         all_keys[File.basename(k)] = Diplomat::Kv.get(k, { nil_values: true, :dc => @consul_config['dc'] })
       end
       all_keys

data/lib/tiller/data/defaults.rb

@@ -6,14 +6,14 @@ require 'tiller/datasource'
 
 class DefaultsDataSource < Tiller::DataSource
   def setup
-    defaults_file = File.join(@config[:tiller_base], 'defaults.yaml')
-    defaults_dir  = File.join(@config[:tiller_base], 'defaults.d')
+    defaults_file = File.join(Tiller::config[:tiller_base], 'defaults.yaml')
+    defaults_dir  = File.join(Tiller::config[:tiller_base], 'defaults.d')
     @defaults_hash = Hash.new
 
     # First, try and load defaults from v2 config
-    if @config.has_key?('defaults')
-      @log.debug("#{self} : Using values from v2 format common.yaml")
-      @defaults_hash.deep_merge!(@config['defaults'])
+    if Tiller::config.has_key?('defaults')
+      Tiller::log.debug("#{self} : Using values from v2 format common.yaml")
+      @defaults_hash.deep_merge!(Tiller::config['defaults'])
     else
       # Read defaults in from defaults file if no v2 config
       # Handle empty files - if YAML didn't parse, it returns false so we skip them
@@ -28,7 +28,7 @@ class DefaultsDataSource < Tiller::DataSource
     if File.directory? defaults_dir
       Dir.glob(File.join(defaults_dir,'*.yaml')).each do |d|
         yaml = YAML.load(open(d))
-        @log.debug("Loading defaults from #{d}")
+        Tiller::log.debug("Loading defaults from #{d}")
         @defaults_hash.deep_merge!(yaml) if yaml != false
       end
     end
@@ -52,7 +52,7 @@ class DefaultsDataSource < Tiller::DataSource
         # Previous versions of Tiller didn't throw an error when we had an empty
         # template config definition in a defaults file. Tiller 0.7.3 "broke" this, so while it's arguably the
         # correct thing to bail out, in the interests of backwards-compatibility, we now instead log a warning and continue.
-        @log.warn("Warning, empty config for #{template_name}")
+        Tiller::log.warn("Warning, empty config for #{template_name}")
         Hash.new
       end
     else
@@ -67,7 +67,7 @@ class DefaultsDataSource < Tiller::DataSource
         values.key?('target') ? values : Hash.new
       else
         # See comments for values function.
-        @log.warn("Warning, empty config for #{template_name}")
+        Tiller::log.warn("Warning, empty config for #{template_name}")
         Hash.new
       end
     else

data/lib/tiller/data/environment.rb

@@ -4,8 +4,8 @@ class EnvironmentDataSource < Tiller::DataSource
 
   def setup
     @plugin_config = Tiller::Environment.defaults
-    if @config.has_key? 'environment' and @config['environment'].is_a? Hash
-      @plugin_config.merge!(@config['environment'])
+    if Tiller::config.has_key? 'environment' and Tiller::config['environment'].is_a? Hash
+      @plugin_config.merge!(Tiller::config['environment'])
     end
   end
 

data/lib/tiller/data/environment_json.rb

@@ -13,12 +13,12 @@ class EnvironmentJsonDataSource < Tiller::DataSource
         @json_structure = parse.is_a?(Hash) ? parse : Hash.new
         if @json_structure[VERSION_KEY].is_a? Integer
           @json_version = @json_structure[VERSION_KEY]
-          @log.debug("Using v#{@json_version} tiller_json format")
+          Tiller::log.debug("Using v#{@json_version} tiller_json format")
         else
           @json_version = 1
         end
       rescue JSON::ParserError
-        @log.warn('Warning : Error parsing tiller_json environment variable')
+        Tiller::log.warn('Warning : Error parsing tiller_json environment variable')
       end
     else
       @json_structure = Hash.new

data/lib/tiller/data/external_file.rb

@@ -7,8 +7,8 @@ class ExternalFileDataSource < Tiller::DataSource
 
   def setup
     @merged_values = Hash.new
-    if @config.has_key?('external_files')
-      files = @config['external_files']
+    if Tiller::config.has_key?('external_files')
+      files = Tiller::config['external_files']
       files.each do |file|
         @merged_values.merge!(parse_file(file)) do |key, old, new|
           warn_merge(key, old, new, 'external file data', file)
@@ -23,14 +23,14 @@ class ExternalFileDataSource < Tiller::DataSource
 
   def parse_file(filename)
     raise("External file '#{filename}' could not be loaded") unless File.file?(filename)
-    @log.debug("#{self} : Loading #{filename}")
+    Tiller::log.debug("#{self} : Loading #{filename}")
     parse = nil
 
     # First try to load it as JSON
     if ! parse
       begin
         parse = JSON.parse(File.read(filename))
-        @log.debug("#{self} : #{filename} is in JSON format")
+        Tiller::log.debug("#{self} : #{filename} is in JSON format")
       rescue JSON::ParserError
       end
     end
@@ -39,7 +39,7 @@ class ExternalFileDataSource < Tiller::DataSource
     if ! parse
       begin
         parse = YAML.load(File.read(filename))
-        @log.debug("#{self} : #{filename} is in YAML format")
+        Tiller::log.debug("#{self} : #{filename} is in YAML format")
       rescue Psych::SyntaxError
       end
     end

data/lib/tiller/data/file.rb

@@ -4,26 +4,26 @@ class FileDataSource < Tiller::DataSource
   # Open and parse the environment file. Tries from v2 format common.yaml first, if that
   # failes, then it looks for separate environment files.
   def setup
-    if @config.has_key?('environments')
+    if Tiller::config.has_key?('environments')
       # Try and load from v2 format common.yaml
-      if @config['environments'].has_key?(@config[:environment])
-        @log.debug("#{self} : Using values from v2 format common.yaml")
-        if @config['environments'][@config[:environment]].is_a? Hash
-          @config_hash = @config['environments'][@config[:environment]]
+      if Tiller::config['environments'].has_key?(Tiller::config[:environment])
+        Tiller::log.debug("#{self} : Using values from v2 format common.yaml")
+        if Tiller::config['environments'][Tiller::config[:environment]].is_a? Hash
+          @config_hash = Tiller::config['environments'][Tiller::config[:environment]]
         else
           # This permits "stub"" environments, where all the config is provided by another module e.g. defaults
           # See https://github.com/markround/tiller/issues/29
-          @log.info("Using stub environment for #{@config[:environment]}")
+          Tiller::log.info("Using stub environment for #{Tiller::config[:environment]}")
           @config_hash = Hash.new
         end
       else
-        abort("Error : Could not load environment #{@config[:environment]} from common.yaml")
+        abort("Error : Could not load environment #{Tiller::config[:environment]} from common.yaml")
       end
     else
       # Try and load from v1 format files
       begin
-        env_file = File.join(@config[:tiller_base], 'environments',
-                             "#{@config[:environment]}.yaml")
+        env_file = File.join(Tiller::config[:tiller_base], 'environments',
+                             "#{Tiller::config[:environment]}.yaml")
         @config_hash = YAML.load(open(env_file))
       rescue
         abort("Error : Could not load environment file #{env_file}")

data/lib/tiller/data/xml_file.rb

@@ -7,18 +7,18 @@ require 'crack'
 class XmlFileDataSource < Tiller::DataSource
 
   def global_values
-    parse_xml(@config)
+    parse_xml(Tiller::config)
   end
 
   def values(template)
-    parse_xml(@config['environments'][@config[:environment]][template])
+    parse_xml(Tiller::config['environments'][Tiller::config[:environment]][template])
   end
 
   def parse_xml(config_hash)
     if config_hash.has_key?('xml_file_path') && config_hash.has_key?('xml_file_var')
       path = config_hash['xml_file_path']
       var = config_hash['xml_file_var']
-      @log.info('Opening XML file : ' + path)
+      Tiller::log.info('Opening XML file : ' + path)
       begin
         xml = Crack::XML.parse(File.open(path))
       rescue StandardError => e
@@ -26,7 +26,7 @@ class XmlFileDataSource < Tiller::DataSource
       end
       struct = {}
       struct[var] = xml
-      @log.debug("Created XML structure : #{struct}")
+      Tiller::log.debug("Created XML structure : #{struct}")
       struct
     else
       {}

data/lib/tiller/data/zookeeper.rb

@@ -10,8 +10,8 @@ class ZookeeperDataSource < Tiller::DataSource
     # Set our defaults if not specified
     @zk_config = Tiller::Zookeeper::Defaults
 
-    raise 'No zookeeper configuration block' unless @config.has_key?('zookeeper')
-    @zk_config.merge!(@config['zookeeper'])
+    raise 'No zookeeper configuration block' unless Tiller::config.has_key?('zookeeper')
+    @zk_config.merge!(Tiller::config['zookeeper'])
 
     # Sanity check
     ['uri'].each {|c| raise "Missing Zookeeper configuration #{c}" unless @zk_config.has_key?(c)}
@@ -29,21 +29,21 @@ class ZookeeperDataSource < Tiller::DataSource
 
   def values(template_name)
     path = @zk_config['values']['template']
-      .gsub('%e',@config[:environment])
+      .gsub('%e',Tiller::config[:environment])
       .gsub('%t',template_name)
 
     get_values(path)
   end
 
   def global_values
-    path = @zk_config['values']['global'].gsub('%e',@config[:environment])
-    @log.info("Fetching Zookeeper globals from #{path}")
+    path = @zk_config['values']['global'].gsub('%e',Tiller::config[:environment])
+    Tiller::log.info("Fetching Zookeeper globals from #{path}")
     get_values(path)
   end
 
   def target_values(template_name)
     path = @zk_config['values']['target']
-      .gsub('%e',@config[:environment])
+      .gsub('%e',Tiller::config[:environment])
       .gsub('%t',template_name)
     get_values(path)
   end

data/lib/tiller/datasource.rb

@@ -1,5 +1,3 @@
-require 'tiller/logger'
-
 # Tiller data source base class.
 module Tiller
   # Subclasses provide global_values and/or values (things local to a specific
@@ -7,12 +5,7 @@ module Tiller
   # location, permissions, owner and so on)
   class DataSource
 
-    # Every plugin gets this hash, which is the full parsed config
-    @config ={}
-
-    def initialize(config)
-      @config = config
-      @log = Tiller::Logger.new(config)
+    def initialize
       setup
     end
 
@@ -52,7 +45,7 @@ module Tiller
     end
 
     def ping
-      'ping!' + @config.to_s
+      'ping!' + Tiller::config.to_s
     end
   end
 end

data/lib/tiller/http.rb

@@ -12,8 +12,8 @@ module Tiller::HttpCommon
     # Set our defaults if not specified
     @http_config = Tiller::Http.defaults
 
-    raise 'No HTTP configuration block' unless @config.has_key?('http')
-    @http_config.merge!(@config['http'])
+    raise 'No HTTP configuration block' unless Tiller::config.has_key?('http')
+    @http_config.merge!(Tiller::config['http'])
 
     # Sanity check
     ['uri'].each {|c| raise "HTTP: Missing HTTP configuration #{c}" unless @http_config.has_key?(c)}
@@ -23,14 +23,14 @@ module Tiller::HttpCommon
 
     # Basic auth for resource
     if @http_config.has_key?('username')
-      @log.debug('HTTP: Using basic authentication')
+      Tiller::log.debug('HTTP: Using basic authentication')
       raise 'HTTP: Missing password for authentication' unless @http_config.has_key?('password')
       @client.set_auth(nil, @http_config['username'], @http_config['password'])
     end
 
     # Basic auth for proxy
     if @http_config.has_key?('proxy_username')
-      @log.debug('HTTP: Using proxy basic authentication')
+      Tiller::log.debug('HTTP: Using proxy basic authentication')
       raise 'HTTP: Missing password for proxy authentication' unless @http_config.has_key?('proxy_password')
       @client.set_proxy_auth(@http_config['proxy_username'], @http_config['proxy_password'])
     end
@@ -39,10 +39,10 @@ module Tiller::HttpCommon
 
   # Interpolate the placeholders and return content from a URI
   def get_uri(uri, interpolate={})
-    uri.gsub!('%e', @config[:environment])
+    uri.gsub!('%e', Tiller::config[:environment])
     uri.gsub!('%t', interpolate[:template]) if interpolate[:template]
 
-    @log.debug("HTTP: Fetching #{uri}")
+    Tiller::log.debug("HTTP: Fetching #{uri}")
     resp = @client.get(uri, :follow_redirect => true)
     raise "HTTP: Server responded with status #{resp.status} for #{uri}" if resp.status != 200
     resp.body
@@ -53,7 +53,7 @@ module Tiller::HttpCommon
   def parse(content)
     case @http_config['parser']
       when 'json'
-        @log.debug("HTTP: Using JSON parser")
+        Tiller::log.debug("HTTP: Using JSON parser")
         JSON.parse(content)
       else
         raise "HTTP: Unsupported parser '#{@http_config['parser']}'"

data/lib/tiller/loader.rb

@@ -2,7 +2,6 @@ require 'tiller/templatesource'
 require 'tiller/datasource'
 
 def loader(type,sources)
-
   case type.to_s
     when 'Tiller::DataSource'
       source_path = 'tiller/data'
@@ -27,5 +26,17 @@ def loader(type,sources)
   end
 
   classes
+end
+
+
+def helper_loader(helpers)
+  source_path = 'tiller/helper'
+  loaded = []
+
+  helpers.each do |h|
+    require File.join(source_path,"#{h}.rb")
+    loaded.push(h)
+  end
 
+  loaded
 end

data/lib/tiller/logger.rb

@@ -3,12 +3,12 @@ require 'logger'
 module Tiller
 
   class Logger < Logger
-    def initialize(config)
+    def initialize
       super(STDOUT)
 
       self.level = Logger::WARN
-      self.level = Logger::INFO if config[:verbose]
-      self.level = Logger::DEBUG if config[:debug]
+      self.level = Logger::INFO if Tiller::config[:verbose]
+      self.level = Logger::DEBUG if Tiller::config[:debug]
 
       self.formatter = proc do |_severity, _datetime, _progname, msg|
         "#{msg}\n"

data/lib/tiller/render.rb

@@ -0,0 +1,12 @@
+module Tiller
+  def self.render(template)
+    if Tiller::templates.key?(template)
+      content = Tiller::templates[template]
+      ns = OpenStruct.new(Tiller::tiller)
+      ERB.new(content, nil, '-').result(ns.instance_eval { binding })
+    else
+      Tiller::log.warn("Warning : Requested render of non-existant template #{template}")
+      ""
+    end
+  end
+end

data/lib/tiller/template/consul.rb

@@ -9,13 +9,13 @@ class ConsulTemplateSource < Tiller::TemplateSource
 
   def templates
     path = interpolate("#{@consul_config['templates']}")
-    @log.debug("#{self} : Fetching templates from #{path}")
+    Tiller::log.debug("#{self} : Fetching templates from #{path}")
     templates = Diplomat::Kv.get(path, {:keys => true, :dc => @consul_config['dc']}, :return)
 
     if templates.is_a? Array
       templates.map { |t| File.basename(t) }
     else
-      @log.warn("Consul : No templates could be fetched from #{path}")
+      Tiller::log.warn("Consul : No templates could be fetched from #{path}")
       []
     end
   end

data/lib/tiller/template/file.rb

@@ -1,7 +1,7 @@
 class FileTemplateSource < Tiller::TemplateSource
-  def initialize(config)
+  def initialize
     super
-    @template_dir = File.join(@config[:tiller_base], 'templates/')
+    @template_dir = File.join(Tiller::config[:tiller_base], 'templates/')
   end
 
   # Simply return a list of all the templates in the $tiller_base/templates

data/lib/tiller/template/zookeeper.rb

@@ -6,8 +6,8 @@ class ZookeeperTemplateSource < Tiller::TemplateSource
     # Set our defaults if not specified
     @zk_config = Tiller::Zookeeper::Defaults
 
-    raise 'No zookeeper configuration block' unless @config.has_key?('zookeeper')
-    @zk_config.merge!(@config['zookeeper'])
+    raise 'No zookeeper configuration block' unless Tiller::config.has_key?('zookeeper')
+    @zk_config.merge!(Tiller::config['zookeeper'])
 
     # Sanity check
     ['uri'].each {|c| raise "Missing Zookeeper configuration #{c}" unless @zk_config.has_key?(c)}
@@ -24,8 +24,8 @@ class ZookeeperTemplateSource < Tiller::TemplateSource
   end
 
   def templates
-    path = @zk_config['templates'].gsub('%e',@config[:environment])
-    @log.info("Fetching Zookeeper templates from #{path}")
+    path = @zk_config['templates'].gsub('%e',Tiller::config[:environment])
+    Tiller::log.info("Fetching Zookeeper templates from #{path}")
     templates = []
     if @zk.exists?(path)
       templates = @zk.children(path)
@@ -35,7 +35,7 @@ class ZookeeperTemplateSource < Tiller::TemplateSource
   end
 
   def template(template_name)
-    path = @zk_config['templates'].gsub('%e',@config[:environment]) + "/#{template_name}"
+    path = @zk_config['templates'].gsub('%e',Tiller::config[:environment]) + "/#{template_name}"
     @zk.get(path)[0]
   end
 

data/lib/tiller/templatesource.rb

@@ -1,17 +1,10 @@
-require 'tiller/logger'
-
 # Tiller template source base class
 module Tiller
   # Subclasses provide templates (an array), and individual template contents
   # (a string containing ERB data)
   class TemplateSource
 
-    # Every plugin gets this hash, which is the full parsed config
-    @config = {}
-
-    def initialize(config)
-      @config = config
-      @log = Tiller::Logger.new(config)
+    def initialize
       setup
     end
 
@@ -29,7 +22,7 @@ module Tiller
     end
 
     def ping
-      'ping!' + @config.to_s
+      'ping!' + Tiller::config.to_s
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tiller
 version: !ruby/object:Gem::Version
-  version: 0.7.10
+  version: 0.8.0
 platform: ruby
 authors:
 - Mark Dastmalchi-Round
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-19 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies: []
 description: A tool to create configuration files from a variety of sources, particularly
   useful for Docker containers. See https://github.com/markround/tiller for examples
@@ -45,13 +45,14 @@ files:
 - lib/tiller/loader.rb
 - lib/tiller/logger.rb
 - lib/tiller/options.rb
+- lib/tiller/render.rb
 - lib/tiller/template/consul.rb
 - lib/tiller/template/file.rb
 - lib/tiller/template/http.rb
 - lib/tiller/template/zookeeper.rb
 - lib/tiller/templatesource.rb
 - lib/tiller/util.rb
-homepage: http://www.markround.com
+homepage: http://www.markround.com/blog/categories/tiller/
 licenses:
 - MIT
 metadata: