consul-template-generator 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aaef7a186c5c1fca60d93587c591ae1784f43fc5
-  data.tar.gz: 2a718fbc572f86694d7baa45d3fe2fe00e6d116c
+  metadata.gz: 11a123a605164b3bf85c7d874ae9d731db56cb99
+  data.tar.gz: 9091f83f039d537c0a1b13fac6a99a7546247881
 SHA512:
-  metadata.gz: 0ec46a6583238a47068a2ecb2d9a248c03fcd37484c780f742eb152f79aeb639aa7526249d31384d1a1057aaae91d7b881dd2a03bf2e8fe2d87e0e06371654c1
-  data.tar.gz: fe1eea1260ecc10e3247ecabcf92ab1e05b4e74663c3afdfe6913ba96c36a4c48c704d8f51764df6cdf5d3b8dd0f9fefae0dc2e9399a9da38c83d15f8ce680bd
+  metadata.gz: 4330d15eb334469bad07257f6e66eaaf29dd9f787a652006e9afd9116e714a9d45072c4dce4fbf3fb80d142012f69e0571ac764f349cb39798ad0ae65ff9ca53
+  data.tar.gz: 33406c87edc31d2b4534104bcbbe2a5378690346ca834cadbec809797ab3ad5f7792e9650ff7903c6a00ddf0e0f37c29db140c9506fe496a009c7e1dd51f3d0b

data/bin/consul-template-generator

@@ -5,7 +5,7 @@ require 'consul/template/generator/cmd'
 include Consul::Template::Generator
 
 def verify_opts(opts)
-  !opts[:key].nil? && !opts[:template].nil?
+  !(opts[:templates].empty? || opts[:templates].any? { |k,v| v.nil? })
 end
 
 
@@ -26,14 +26,14 @@ EOC
     options[:consul] = h
   end
 
-  options[:template] = nil
-  opts.on('-t TEMPLATE', '--template TEMPLATE', 'Consul-Template ctmpl file to monitor (required)') do |t|
-    options[:template] = t
+  options[:templates] = {}
+  opts.on('-t TEMPLATES', '--templates TEMPLATES', 'Comma separated list of consul-template ctmpl file and keys to monitor, tmple.ctmpl:tmple-key,tmple2.ctmpl:templ-key2  (required)') do |t|
+    options[:templates] = Hash[t.split(',').collect { |v| v.split(':') } ]
   end
 
-  options[:key] = nil
-  opts.on('-k KEY', '--key KEY', 'Key to store rendered template in (required)') do |k|
-    options[:key] = k
+  options[:session_key] = 'consul-template-generator'
+  opts.on('-s SESSION_KEY', '--session-key SESSION_KEY', 'Key used to lock template generation session [default: consul-template-generator') do |l|
+    options[:session_key] = l
   end
 
   options[:proxy] = nil
@@ -64,8 +64,9 @@ end
 
 opt_parser.parse!
 
+
 unless verify_opts(options)
-  STDOUT.puts "Both '--key' and '--template' must be provided"
+  STDOUT.puts "'--templates' must be provided with <template>:<key> pairs\n\n"
   puts opt_parser
   exit(1)
 end
@@ -74,7 +75,7 @@ if options[:unset_proxy]
   ENV['http_proxy'] = nil
 end
 
-CMD.configure(options[:consul], options[:template], options[:key], options[:log_level], options[:proxy])
+CMD.configure(options[:consul], options[:templates], options[:session_key], options[:log_level], options[:proxy])
 
 ec = 1
 cmd = ARGV[0]

data/lib/consul/template/generator.rb

@@ -31,14 +31,10 @@ module Consul
             self.config.consul_template_binary = ct_binary
           end
 
-          if self.config.template.nil?
+          if self.config.templates.empty? || self.config.templates.any? { |k,v| v.nil? }
             raise "template must be defined in configuration"
           end
 
-          if self.config.template_key.nil?
-            raise "template_key must be defined in configuration"
-          end
-
           Diplomat.configure do |config|
             config.url = "http://#{self.config.consul_host}"
             config.options = self.config.client_options

data/lib/consul/template/generator/cmd.rb

@@ -6,11 +6,11 @@ module Consul
       module CMD
         include Consul::Template::Generator
 
-        def self.configure(consul_host, template, template_key, log_level, proxy = nil)
+        def self.configure(consul_host, templates, session_key, log_level, proxy = nil)
           Consul::Template::Generator.configure do |config|
             config.log_level = log_level
-            config.template = template
-            config.template_key = template_key
+            config.templates = templates
+            config.session_key = session_key
             config.consul_host = consul_host
           end
         end
@@ -19,14 +19,16 @@ module Consul
           cycle_sleep ||= 0.5
           lock_sleep ||= 1.0
           config = Consul::Template::Generator.config
-          uploaded_hash = nil
+          uploaded_hashes = {}
           begin
             runner = CTRunner.new
             runner.acquire_session_lock do
               config.logger.info "Session lock acquired..."
               begin
-                uploaded_hash = runner.run(uploaded_hash) || uploaded_hash
-                sleep cycle_sleep
+                config.templates.each do |template,template_key|
+                  uploaded_hashes[template] = runner.run(template, template_key, uploaded_hashes[template]) || uploaded_hashes[template]
+                  sleep cycle_sleep
+                end
               rescue Interrupt
                 raise # Re-raise to break this rescue block
               rescue ConsulSessionExpired
@@ -60,8 +62,10 @@ module Consul
         def self.run_once
           config = Consul::Template::Generator.config
           begin
-            runner = CTRunner.new
-            result = runner.run
+            config.templates.each do |template,template_key|
+              runner = CTRunner.new
+              result = runner.run template, template_key
+            end
           rescue Exception => e
             config.logger.error "An unexpected error occurred, unable to process template: #{e.message}"
             1

data/lib/consul/template/generator/configuration.rb

@@ -39,25 +39,25 @@ module Consul
       end
 
       class Configuration
-        attr_accessor :template, :template_key, :consul_template_binary, :logger, :log_level
+        attr_accessor :templates, :session_key, :consul_template_binary, :logger, :log_level
         attr_accessor :consul_host, :node, :client_options
 
         def initialize
           @log_level = :debug
           @node = nil
           @consul_host = nil
-          @template = nil
-          @template_key = nil
+          @templates = {}
+          @session_key = 'consul-template-generator'
           @client_options = {}
           @logger = Consul::Template::Generator::STDLogger
         end
 
-        def lock_key
-          "/lock/#{@template_key.sub(/^\//, '')}"
+        def lock_key(key)
+          "/lock/#{key.sub(/^\//, '')}"
         end
 
         def session_lock_key
-          "/lock/session/#{@template_key.sub(/^\//, '')}"
+          @session_key
         end
       end
     end

data/lib/consul/template/generator/ct.rb

@@ -5,9 +5,9 @@ module Consul
   module Template
     module Generator
       class CTRunner
-        def render_template
+        def render_template(template)
           body = nil
-          cmd = %{#{@config.consul_template_binary} -dry -once -template #{@config.template}}
+          cmd = %{#{@config.consul_template_binary} -dry -once -template #{template}}
           procs = ::Open4.popen4(*cmd) do |pid, stdin, stdout, stderr|
             body = stdout.read.strip
             # consul-template -dry inserts '> \n' at the top of stdout, remove it

data/lib/consul/template/generator/key_value.rb

@@ -5,8 +5,8 @@ module Consul
     module Generator
       class CTRunner
 
-        def acquire_lock(lock_key = nil)
-          lock_key ||= @config.lock_key
+        def acquire_lock(target_key)
+          lock_key = @config.lock_key target_key
           @config.logger.debug "Attempting to acquire lock on key: #{lock_key}"
           Consul::Template::Generator.renew_session @session
           unless Diplomat::Lock.acquire(lock_key, @session)
@@ -27,10 +27,10 @@ module Consul
           end
         end
 
-        def upload_template(raw_template)
-          @config.logger.info "Uploading key: #{@config.template_key}"
+        def upload_template(template_key, raw_template)
+          @config.logger.info "Uploading key: #{template_key}"
           begin
-            Diplomat::Kv.put(@config.template_key, raw_template)
+            Diplomat::Kv.put(template_key, raw_template)
           rescue Exception => e
             raise TemplateUploadError, "Encountered an unexpected error while uploading template: #{e.message}"
           end

data/lib/consul/template/generator/run.rb

@@ -4,11 +4,11 @@ module Consul
   module Template
     module Generator
       class CTRunner
-        def run(comp_hash = nil)
+        def run(template, template_key, comp_hash = nil)
           status, body, hash, uploaded_hash = nil, nil, nil, nil
-          acquire_lock do
-            @config.logger.debug "Attempting to render template: #{@config.template}"
-            status, body, hash = render_template
+          acquire_lock template_key do
+            @config.logger.debug "Attempting to render template: #{template}"
+            status, body, hash = render_template template
             unless status == 0
               raise TemplateRenderError, "consul-template exited with on-zero exit status"
             end
@@ -17,9 +17,9 @@ module Consul
             end
             @config.logger.debug "Template rendered..."
             if comp_hash.nil? || comp_hash != hash
-              @config.logger.info "Change in template discovered, attempting to upload to key #{@config.template_key}"
+              @config.logger.info "Change in template discovered, attempting to upload to key #{template_key}"
               @config.logger.debug "Existing hash: #{comp_hash || 'nil'}, new hash: #{hash}"
-              uploaded = upload_template(body)
+              uploaded = upload_template(template_key, body)
               if uploaded
                 @config.logger.info "New template uploaded..."
                 uploaded_hash = hash

data/lib/consul/template/generator/version.rb

@@ -1,7 +1,7 @@
 module Consul
   module Template
     module Generator
-      VERSION = '0.1.2'
+      VERSION = '0.2.0'
     end
   end
 end

data/spec/ct_spec.rb

@@ -24,8 +24,7 @@ end
 describe 'Consul::Template::Generator::CTRunner' '#render_template' do
   before do
     Consul::Template::Generator.configure do |config|
-      config.template = '/etc/test-template.ctmpl'
-      config.template_key = '/test-template'
+      config.templates = {'/etc/test-template.ctmpl' => '/test-template'}
       config.consul_template_binary = 'consul-template'
     end
   end
@@ -36,7 +35,7 @@ describe 'Consul::Template::Generator::CTRunner' '#render_template' do
       exp_hash = '54b0c58c7ce9f2a8b551351102ee0938'
       setup_open4(exp_out, 0, 101)
       runner = CTRunner.new('test-session')
-      exit_code, body, hash = runner.render_template
+      exit_code, body, hash = runner.render_template Consul::Template::Generator.config.templates['/etc/test-template.ctmpl']
       expect(body).to eql(exp_out)
       expect(hash).to eql(exp_hash)
       expect(exit_code).to eql(@status)

data/spec/init_spec.rb

@@ -8,8 +8,7 @@ include Consul::Template::Generator
 describe 'Consul::Template::Generator::CTRunner' '#initialize' do
   before(:each) do
     Consul::Template::Generator.configure do |config|
-      config.template = 'test-session-template.ctmpl'
-      config.template_key = 'test-session-template'
+      config.templates = {'test-session-template.ctmpl' => 'test-session-template' }
       config.node = 'test-node'
       config.log_level = :off
       config.consul_template_binary = 'consul-template'

data/spec/key_value_spec.rb

@@ -10,18 +10,18 @@ include Consul::Template::Generator
 describe 'Consul::Template::Generator::CTRunner' '#acquire_lock' do
   before do
     Consul::Template::Generator.configure do |config|
-      config.template = 'test-template.ctmpl'
-      config.template_key = '/test-template'
+      config.templates = { 'test-template.ctmpl' => '/test-template' }
       config.consul_host = '127.0.0.1:8500'
       config.consul_template_binary = 'consul-template'
       config.log_level = :off
     end
+    @config = Consul::Template::Generator.config
   end
 
   context 'acquires lock' do
     it 'clean lock acquisition' do
       runner = CTRunner.new('test-session')
-      runner.acquire_lock do
+      runner.acquire_lock @config.templates['test-template.ctmpl'] do
        expect(true).to be_truthy ## This is simply to assert we are able to execute code in the block
       end
       expect(WebMock).to have_requested(:put, 'http://127.0.0.1:8500/v1/kv/lock/test-template').with(:query => {:acquire => 'test-session'})
@@ -30,7 +30,7 @@ describe 'Consul::Template::Generator::CTRunner' '#acquire_lock' do
 
     it 'handles being unable to acquire lock' do
       runner = CTRunner.new('test-session-lock-fail')
-      expect { runner.acquire_lock { puts 'hi' } }.to raise_error(KeyNotLockedError)
+      expect { runner.acquire_lock @config.templates['test-template.ctmpl'] { puts 'hi' } }.to raise_error(KeyNotLockedError)
       expect(WebMock).to have_requested(:put, 'http://127.0.0.1:8500/v1/kv/lock/test-template').with(:query => {:acquire => 'test-session-lock-fail'})
       expect(WebMock).to_not have_requested(:put, 'http://127.0.0.1:8500/v1/kv/lock/test-template').with(:query => {:release => 'test-session-lock-fail'})
     end
@@ -40,8 +40,8 @@ end
 describe 'Consul::Template::Generator::CTRunner' '#acquire_session_lock' do
   before do
     Consul::Template::Generator.configure do |config|
-      config.template = 'test-template.ctmpl'
-      config.template_key = '/test-template'
+      config.templates = { 'test-template.ctmpl' => '/test-template' }
+      config.session_key = '/session/test-template'
       config.consul_host = '127.0.0.1:8500'
       config.consul_template_binary = 'consul-template'
       config.log_level = :off
@@ -71,17 +71,17 @@ describe 'Consul::Template::Generator::CTRunner' '#upload_template' do
   context 'uploads template' do
     before do
       Consul::Template::Generator.configure do |config|
-        config.template = 'test-template.ctmpl'
-        config.template_key = '/test-template'
+        config.templates = { 'test-template.ctmpl' => '/test-template' }
         config.consul_host = '127.0.0.1:8500'
         config.consul_template_binary = 'consul-template'
         config.log_level = :off
       end
+      @config = Consul::Template::Generator.config
     end
 
     it 'does a clean upload' do
       runner = CTRunner.new('test-session')
-      success = runner.upload_template('this is a test')
+      success = runner.upload_template(@config.templates['test-template.ctmpl'], 'this is a test')
       expect(success).to be_truthy
       expect(WebMock).to have_requested(:put, 'http://127.0.0.1:8500/v1/kv/test-template').with(:body => 'this is a test')
     end
@@ -90,17 +90,17 @@ describe 'Consul::Template::Generator::CTRunner' '#upload_template' do
   context 'handles template upload failure' do
     before do
       Consul::Template::Generator.configure do |config|
-        config.template = 'test-template.ctmpl'
-        config.template_key = '/test-template-failure'
+        config.templates = { 'test-template.ctmpl' => '/test-template-failure' }
         config.consul_host = '127.0.0.1:8500'
         config.consul_template_binary = 'consul-template'
         config.log_level = :off
       end
+      @config = Consul::Template::Generator.config
     end
 
     it 'does a clean upload' do
       runner = CTRunner.new('test-session')
-      expect { runner.upload_template('this is a fail test') }.to raise_error(TemplateUploadError)
+      expect { runner.upload_template(@config.templates['test-template.ctmpl'], 'this is a fail test') }.to raise_error(TemplateUploadError)
       expect(WebMock).to have_requested(:put, 'http://127.0.0.1:8500/v1/kv/test-template-failure').with(:body => 'this is a fail test')
     end
   end

data/spec/run_spec.rb

@@ -13,37 +13,37 @@ describe 'Consul::Template::Generator::CTRunner' '#run' do
   context 'run' do
     it 'handles a clean run' do
       exp_hash = 'bbf9afe7431caf5f89a608bc31e8d822'
-      expect(@runner).to receive(:render_template).with(no_args).and_return([0, 'test body', exp_hash])
-      expect(@runner).to receive(:upload_template).with('test body').and_return(true)
-      hash = @runner.run
+      expect(@runner).to receive(:render_template).with('test-template').and_return([0, 'test body', exp_hash])
+      expect(@runner).to receive(:upload_template).with('/test-template', 'test body').and_return(true)
+      hash = @runner.run 'test-template', '/test-template'
       expect(hash).to eql(exp_hash)
     end
 
     it "doesn't upload unchanged template" do
       exp_hash = 'bbf9afe7431caf5f89a608bc31e8d822'
-      expect(@runner).to receive(:render_template).with(no_args).and_return([0, 'test body', exp_hash])
+      expect(@runner).to receive(:render_template).with('test-template').and_return([0, 'test body', exp_hash])
       expect(@runner).not_to receive(:upload_template)
-      hash = @runner.run exp_hash
+      hash = @runner.run  'test-template', '/test-template', exp_hash
       expect(hash).to be_nil
     end
 
     it 'handles non-zero exit status' do
-      expect(@runner).to receive(:render_template).with(no_args).and_return([1, 'not used', 'not used'])
+      expect(@runner).to receive(:render_template).with('test-template').and_return([1, 'not used', 'not used'])
       expect(@runner).not_to receive(:upload_template)
-      expect { @runner.run }.to raise_exception(TemplateRenderError)
+      expect { @runner.run 'test-template', '/test-template' }.to raise_exception(TemplateRenderError)
     end
 
     it 'handles empty rendered template' do
-      expect(@runner).to receive(:render_template).with(no_args).and_return([0, '', 'not used'])
+      expect(@runner).to receive(:render_template).with('test-template').and_return([0, '', 'not used'])
       expect(@runner).not_to receive(:upload_template)
-      expect { @runner.run }.to raise_exception(TemplateRenderError)
+      expect { @runner.run 'test-template', '/test-template' }.to raise_exception(TemplateRenderError)
     end
 
     it 'handles bad return from upload_template' do
       exp_hash = 'bbf9afe7431caf5f89a608bc31e8d822'
-      expect(@runner).to receive(:render_template).with(no_args).and_return([0, 'test body', exp_hash])
-      expect(@runner).to receive(:upload_template).with('test body').and_return(false)
-      expect { @runner.run }.to raise_exception(TemplateUploadError)
+      expect(@runner).to receive(:render_template).with('test-template').and_return([0, 'test body', exp_hash])
+      expect(@runner).to receive(:upload_template).with('/test-template', 'test body').and_return(false)
+      expect { @runner.run 'test-template', '/test-template' }.to raise_exception(TemplateUploadError)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: consul-template-generator
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Brian Oldfield
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-26 00:00:00.000000000 Z
+date: 2015-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler