cindy-cm 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 774f6b5df9922b3a6771968f4fb61e05d8b0f3dc
-  data.tar.gz: 647e09f6a7ebb222966f785c49492a525fd92c5f
+  metadata.gz: f8c7c22d266d8267c749cd4c9b98eb41a52af41c
+  data.tar.gz: 880741fc31c94b0f89aa77d6f7c250c1310d322b
 SHA512:
-  metadata.gz: 8ecafc4acc58778989dbab0e650d18a70e026ccf985593ca1c1d5adf2003da8c804b90e5bfae9bad47571a90e9260335046f1a264c208fb0c8028052c411f309
-  data.tar.gz: 2a51c783e0ab07d5b95e0448c5b8e7bf6737cc7804dfc3935ef56fe629c29b23b7bab67d55a1c3d7c946c805dc5c563a7acefbe3566f0c85f56257cdd7f534a8
+  metadata.gz: af5a8f616854bad4d4fc7be8dcc234abbd597cda1c00e3a5e1a191ab28b7ebc9fa0fd5aadddf0753d843132f349f9741c465a5915f91d08707086ec1ea7c5d80
+  data.tar.gz: 928a046d7dc654ed9f9abbf18ac4677091bb50dc2b1c9d7a797161459fb6fdd336a060bdece1780dcc6fe8a5fe5a827c9bde36df6cd6e939e7162b26a11d09cd

data/Changelog.md

@@ -1,3 +1,9 @@
+### Changes from 0.1.1 to ?.?.?
+
+### Changes from 0.1.0 to 0.1.1
+
+* force encoding to ASCII-8BIT of data send to stdin through ssh
+
 ### Changes from 0.0.1 to 0.1.0
 
 * configuration format changed (XML => Ruby)

data/README.md

@@ -1,6 +1,6 @@
 ## Introduction
 
-Tired to modify your configuration files depending on the targeted computer? Turn them out into ERB templates and deploy them in one command.
+Tired to modify your configuration files depending on the targeted host? Turn them out into ERB templates and deploy them in one command.
 
 The purpose is to implement a kind of shell with limited dependencies to automate configuration and deployment on various (Unix) environments.
 
@@ -10,7 +10,7 @@ Dependencies: net-ssh, highline
 
 `gem install cindy-cm`
 
-## Usage
+## Usage of cindy command
 
 * reload                        => force Cindy to reload its configuration file
 * environment (shortcut: env)
@@ -22,16 +22,18 @@ Dependencies: net-ssh, highline
             * deploy            => install the generated file on the given environment
             * print             => display output configuration file as it would be deployed on the given environment
             * details           => list all applicable variables to the given template, their values and scopes
+
 ## Example
 
 Create ~/.cindy as follows:
+
 ```ruby
 # create 2 environments named "production" and "development"
-environment :development, 'file:///'
+environment :development
 environment :production, 'ssh://root@www.xxx.tld/'
 
-# register the template /home/julp/cindy/templates/nginx.conf.tpl (see below) for our nginx configuration
-template :nginx, '/home/julp/cindy/templates/nginx.conf.tpl' do
+# register the template ~/cindy/templates/nginx.conf.tpl (see below) for our nginx configuration
+template :nginx, '~/cindy/templates/nginx.conf.tpl' do
     # default variables
 
     # have_gzip_static will be set to true or false depending on the result of the following command
@@ -49,10 +51,16 @@ template :nginx, '/home/julp/cindy/templates/nginx.conf.tpl' do
         var :server_name, 'www.xxx.lan'
         var :root, '/home/julp/app/public'
     end
+
+    # after deployment, check syntax
+    postcmd 'nginx -tc $INSTALL_FILE'
+    # if no error, reload configuration
+    postcmd 'nginx -s reload'
 end
 ```
 
-And /home/julp/cindy/templates/nginx.conf.tpl as:
+And ~/cindy/templates/nginx.conf.tpl as:
+
 ```
 # <%= _install_file_ %>
 
@@ -71,6 +79,7 @@ server {
 ```
 
 Running `cindy template nginx environment production print`, result in:
+
 ```
 # /usr/local/etc/nginx.conf
 
@@ -84,19 +93,20 @@ server {
 (if we admit that nginx is built, on production environment, with Gzip Precompression module)
 
 After `cindy template nginx environment production deploy`, output of `ls -l /etc/nginx.conf*` is:
+
 ```
 lrwxrwxrwx [...] /usr/local/etc/nginx.conf -> /usr/local/etc/nginx.conf.201502262311
 -rw-r--r-- [...] /usr/local/etc/nginx.conf.201502262209                              # file at previous deployment
 -rw-r--r-- [...] /usr/local/etc/nginx.conf.201502262311                              # current version (1h02m later)
 ```
 
-## What is a *command* typed variable?
+## What is a *Command* object?
 
 It is a kind of dynamic variable: instead of hardcoding a value which depends on the remote host, we execute the associated command before each
 time the template is rendered. It is more convenient mainly if this value can change at any time.
 
-The result of the command is a boolean based on its exit status (0 => true, everithing else => false) if the command does not print anything on
-standard output else a string with the content of standard output.
+The result of the command is a boolean based on its exit status (0 => true, everything else => false) if the command does not print anything on
+standard output else a string with the content sent on standard output.
 
 In the example above, `nginx -V 2>&1 >/dev/null | grep -qF -- --with-http_gzip_static_module` is intended to determine if nginx, on the remote
 server, is compiled or not with the gzip_static module.

data/lib/cindy/all.rb

@@ -4,6 +4,7 @@ require 'cindy/command'
 require 'cindy/environment'
 require 'cindy/variable'
 require 'cindy/template'
+require 'cindy/executor/base'
 require 'cindy/executor/ssh'
 require 'cindy/executor/local'
 

data/lib/cindy/cindy.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module Cindy
 
     class UndefinedEnvironmentError < ::NameError
@@ -11,6 +13,7 @@ module Cindy
 
     class Cindy
 
+        # Default location of Cindy's configuration file
         CONFIGURATION_FILE = File.expand_path '~/.cindy'
 
         module DSL
@@ -20,6 +23,10 @@ module Cindy
                     @envname = envname
                 end
 
+                def cmd(command, options = {})
+                    Command.new command, options
+                end
+
                 def var(varname, value)
                     @tpl.set_variable @envname, varname, value
                 end
@@ -32,6 +39,10 @@ module Cindy
                     @tpl = tpl
                 end
 
+                def cmd(command, options = {})
+                    Command.new command, options
+                end
+
                 def var(varname, value)
                     @tpl.set_variable nil, varname, value
                 end
@@ -42,6 +53,10 @@ module Cindy
                     @tpl.set_path_for_environment envname, file
                     TemplateEnvironmentNode.new(@tpl, envname).instance_eval &block if block_given?
                 end
+
+                def postcmd(cmd, options = {})
+                    @tpl.add_postcmd cmd, options
+                end
             end
 
             class CindyNode
@@ -55,23 +70,40 @@ module Cindy
                     tpl
                 end
 
-                def environment(envname, uri = nil)
+                def environment(envname, uri = '')
                     @cindy.environment_add envname, uri
                 end
             end
         end
 
+        # DSL
+        # \@!method environment(envname, uri = '')
+        # \@!method template(tplname, path, &block)
+
+        # @return [Logger] the logger associated to the cindy instance
+        attr_accessor :logger
+
+        # Creates an "empty" Cindy object
         def initialize
             @environments = {}
             @templates = {}
+            @logger = Logger.new STDERR
         end
 
+        # Creates a Cindy object from a string
+        #
+        # @param string [String] the configuration string to evaluate
+        # @return [Cindy]
         def self.from_string(string)
             cindy = Cindy.new
             DSL::CindyNode.new(cindy).instance_eval string
             cindy
         end
 
+        # Creates a Cindy object from a file
+        #
+        # @param filename [String] the file to evaluate ; default location {CONFIGURATION_FILE} is used if nil
+        # @return [Cindy]
         def self.load(filename = nil)
             @filename = filename || CONFIGURATION_FILE
             cindy = Cindy.new
@@ -83,36 +115,67 @@ module Cindy
             (@environments.values.map(&:to_s) + [''] + @templates.values.map(&:to_s)).join("\n")
         end
 
+        # Get known environments
+        #
+        # @return [Array<Symbol>] list of environment names
         def environments
             @environments.values
         end
 
+        # Does environment exist?
+        #
+        # @param envname [String, Symbol] the name of the environment to check for existence
         def has_environment?(envname)
             envname = envname.intern
             @environments.key? envname
         end
 
+        # Add a new environment
+        #
+        # @param envname [String, Symbol] the name of the new environment
+        # @param attributes [String] the uri of the host (eg 'ssh://user@1.2.3.4/' for a
+        #  remote one or 'file:///' to work directely on actual host)
+        # @return [Environment] the registered environment
         def environment_add(envname, attributes)
             envname = envname.intern
             # assert !@environments.key? envname
             @environments[envname] = Environment.new(envname, attributes)
         end
 
+        # Get registered templates
+        #
+        # @return [Array<Symbol>] list of template names
         def templates
             @templates.values
         end
 
+        # Does template exist?
+        #
+        # @param tplname [String, Symbol] the name of the template to check for existence
         def has_template?(tplname)
             tplname = tplname.intern
             @templates.key? tplname
         end
 
+        # Add a new template
+        #
+        # @param tplname [String, Symbol] the name of the new template
+        # @param file [String] the location of the template file. Note it is expanded
+        #  ({File#expand_path}) to permit usage of ~ so it may be a good idea to avoid
+        #  relative paths
+        # @return [Template] the registered template
         def template_add(tplname, file)
             tplname = tplname.intern
             # assert !@templates.key? name
-            @templates[tplname] = Template.new File.expand_path(file), tplname
+            @templates[tplname] = Template.new self, File.expand_path(file), tplname
         end
 
+        # Print on stdout the result of template generation
+        #
+        # @param envname [String, Symbol] the name of the environment
+        # @param tplname [String, Symbol] the name of the template
+        # @raise [UndefinedEnvironmentError] if environment does not exist
+        # @raise [UndefinedTemplateError] if template does not exist
         def template_environment_print(envname, tplname)
             envname = envname.intern
             tplname = tplname.intern
@@ -121,6 +184,12 @@ module Cindy
             @templates[tplname].print @environments[envname]
         end
 
+        # Deploy the result of template generation on the given environment
+        #
+        # @param envname [String, Symbol] the name of the environment
+        # @param tplname [String, Symbol] the name of the template
+        # @raise [UndefinedEnvironmentError] if environment does not exist
+        # @raise [UndefinedTemplateError] if template does not exist
         def template_environment_deploy(envname, tplname)
             envname = envname.intern
             tplname = tplname.intern
@@ -129,6 +198,12 @@ module Cindy
             @templates[tplname].deploy @environments[envname]
         end
 
+        # Print on stdout a detail (value and scope) of applicable variables
+        #
+        # @param envname [String, Symbol] the name of the environment
+        # @param tplname [String, Symbol] the name of the template
+        # @raise [UndefinedEnvironmentError] if environment does not exist
+        # @raise [UndefinedTemplateError] if template does not exist
         def template_environment_variables(envname, tplname)
             envname = envname.intern
             tplname = tplname.intern

data/lib/cindy/command.rb

@@ -1,7 +1,8 @@
 module Cindy
     class Command
-        def initialize(command)
+        def initialize(command, options = {})
             @command = command
+            @options = options
         end
 
         def to_s
@@ -9,11 +10,11 @@ module Cindy
         end
 
         def inspect
-            "#{self.class.name}.new(#{@command.inspect})"
+            "#{self.class.name}.new(#{@command.inspect}, TODO)"
         end
 
         def call(executor)
-            executor.exec(@command, nil, true)
+            executor.exec(@command, @options)
         end
     end
 end

data/lib/cindy/executor/base.rb

@@ -0,0 +1,101 @@
+require 'uri'
+
+module Cindy
+    module Executor
+        class CommandFailedError < StandardError
+        end
+
+        class Base
+            # X
+            #
+            # @param [Logger] logger
+            def initialize(logger)
+                @logger = logger
+            end
+
+            def self.from_uri(uri, logger)
+                uri = URI.parse(uri)
+                ObjectSpace.each_object(Class).select { |v| return v.new(uri, logger) if v.ancestors.include?(self) && v.handle?(uri) }
+                raise Exception.new 'Unexpected protocol'
+            end
+
+            # Executes the given command
+            #
+            # @param command [String] the command to execute
+            # @param options [Hash] the options to execute the command with
+            # @option options [String] :stdin the string to send as/on stdin
+            # @option options [Boolean] :ignore_failure don't raise an exception if true when the command returns a non 0 exit value
+            # @option options [Hash] :env the environment variables to set/pass for command execution
+            # @option options [Boolean] :check_status_only simply return true if the command is successful else false
+            # @return [String, Boolean]
+            def exec(command, options = {})
+=begin
+                stdout, stderr, status = exec_imp command, options[:stdin]
+                stdout.chomp!
+                # <logging>
+                if status.zero?
+                    if stdout.empty?
+                        @logger.info 'Command "%s" executed successfully' % command
+                    else
+                        @logger.info 'Command "%s" executed successfully (with "%s" returned)' % [ command, stdout ]
+                    end
+                else
+                    @logger.send(options[:ignore_failure] ? :warn : :error, 'Command "%s" failed with "%s"' % [ command, stderr ])
+                end
+                # </logging>
+                return status.zero? if options[:check_status_only]
+                raise CommandFailedError.new "Command '#{command}' failed" if !options[:ignore_failure] && 0 != status
+=end
+                stdout, stderr, status = exec_and_log command, options
+                # ?!?
+                stdout
+            end
+
+            def exec!(command, options = {})
+                stdout, stderr, status = exec_and_log command, options
+                raise CommandFailedError.new "Command '#{command}' failed" unless 0 == status
+                stdout
+            end
+
+            # Close the eventual underlaying connection
+            def close
+                # NOP
+            end
+
+private
+
+            def exec_and_log(command, options = {})
+                stdout, stderr, status = exec_imp command, options[:stdin]
+                stdout.chomp!
+                # <logging>
+                if status.zero?
+                    if stdout.empty?
+                        @logger.info 'Command "%s" executed successfully' % command
+                    else
+                        @logger.info 'Command "%s" executed successfully (with "%s" returned)' % [ command, stdout ]
+                    end
+                else
+                    @logger.send(options[:ignore_failure] ? :warn : :error, 'Command "%s" failed with "%s"' % [ command, stderr ])
+                end
+                [ stdout, stderr, status ]
+            end
+
+protected
+
+            # @abstract
+            def self.handle?(uri)
+                false
+            end
+
+            # @abstract
+            # @param command [String] the command to execute
+            # @return [Array<(String, String, Fixnum)>] an array containing the following elements (in this order):
+            # 1. output on stdout
+            # 2. output on stderr
+            # 3. exit status
+            def exec_imp(command, stdin_str)
+                raise NotImplementedError.new
+            end
+        end
+    end
+end

data/lib/cindy/executor/local.rb

@@ -1,28 +1,34 @@
+require 'uri'
 require 'open3'
 
 module Cindy
     module Executor
-        class Local
-            def exec(command, stdin_str = nil, status_only = false)
+        class Local < Base
+            def self.handle?(uri)
+                [ nil, 'file' ].include? uri.scheme
+            end
+
+            def initialize(uri, logger)
+                super logger
+            end
+
+            def exec_imp(command, stdin_str)
                 exit_status = 1
                 stdout_str = stderr_str = ''
-                Open3.popen3({ 'PATH' => "#{ENV['PATH']}:/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin" }, command) do |stdin, stdout, stderr, wait_thr|
-                    if stdin_str
-                        stdin.write stdin_str
-                        stdin.close
+                begin
+                    Open3.popen3({ 'PATH' => "#{ENV['PATH']}:/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin" }, command) do |stdin, stdout, stderr, wait_thr|
+                        if stdin_str
+                            stdin.write stdin_str
+                            stdin.close
+                        end
+                        stdout_str = stdout.read
+                        stderr_str = stderr.read
+                        exit_status = wait_thr.value.exitstatus
                     end
-                    stdout_str = stdout.read
-                    stderr_str = stderr.read
-                    exit_status = wait_thr.value
+                rescue Errno::ENOENT => e
+                    stderr_str = e.message
                 end
-# puts [ command, stderr_str, exit_status ].inspect
-                raise Exception.new if 0 != exit_status && !stderr_str.empty?
-                return nil if status_only && 0 != exit_status
-                stdout_str.chomp
-            end
-
-            def close
-                # NOP
+                [ stdout_str, stderr_str, exit_status ]
             end
         end
     end

data/lib/cindy/executor/ssh.rb

@@ -1,38 +1,38 @@
+require 'uri'
 require 'net/ssh'
 
 module Cindy
     module Executor
-        class SSH
-            def initialize(cnx)
-                @cnx = cnx
+        class SSH < Base
+            def self.handle?(uri)
+                'ssh' == uri.scheme
             end
 
-            def exec(command, stdin_str = nil, status_only = false)
+            def initialize(uri, logger)
+                @cnx = Net::SSH.start(uri.host, uri.user)
+                super logger
+            end
+
+            def exec_imp(command, stdin_str)
                 exit_status = 1
-#                 if stdin_str
-                    stdout_str = stderr_str = ''
-                    @cnx.open_channel do |channel|
-                        channel.exec(command) do |ch, success|
-                            channel.on_data do |ch, data|
-                                stdout_str += data
-                            end
-                            channel.on_extended_data do |ch, type, data|
-                                stderr_str += data
-                            end
-                            channel.on_request 'exit-status' do |ch, data|
-                                exit_status = data.read_long
-                            end
-                            channel.send_data stdin_str if stdin_str
-                            channel.eof!
+                stdout_str = stderr_str = ''
+                @cnx.open_channel do |channel|
+                    channel.exec(command) do |ch, success|
+                        channel.on_data do |ch, data|
+                            stdout_str += data
+                        end
+                        channel.on_extended_data do |ch, type, data|
+                            stderr_str += data
+                        end
+                        channel.on_request 'exit-status' do |ch, data|
+                            exit_status = data.read_long
                         end
+                        channel.send_data stdin_str.force_encoding('ASCII-8BIT') if stdin_str
+                        channel.eof!
                     end
-                    @cnx.loop
-#                 else
-#                     result = @cnx.exec!(command)
-#                     result.chomp if result.respond_to? :chomp # as result can be nil <=> result.chomp if result <=> result.try? :chomp (rails way)
-#                 end
-                return nil if status_only && 0 != exit_status
-                stdout_str.chomp
+                end
+                @cnx.loop
+                [ stdout_str, stderr_str, exit_status ]
             end
 
             def close

data/lib/cindy/template.rb

@@ -1,18 +1,20 @@
 require 'erb'
-require 'uri'
 require 'ostruct'
+require 'shellwords'
 
 module Cindy
     class Template
 
-        attr_reader :file, :alias, :paths, :defvars, :envvars
+        attr_reader :file, :alias, :paths, :defvars, :envvars, :postcmds
 
-        def initialize(file, name)
+        def initialize(owner, file, name)
+            @owner = owner # owner is Cindy objet
             @file = file # local template filename
             @alias = name
             @paths = {}   # remote filenames (<environment name> => <filename>)
             @defvars = {} # default/global variables
             @envvars = {} # environment specific variables
+            @postcmds = [] # commands to run after deployment
         end
 
         IDENT_STRING = ' ' * 4
@@ -38,15 +40,25 @@ module Cindy
             puts render(env)
         end
 
+        def add_postcmd(cmd, options)
+            @postcmds << cmd
+        end
+
         def deploy(env)
             executor = executor_for_env env
             remote_filename = @paths[env.name]
             sudo = ''
-            sudo = 'sudo ' unless 0 == executor.exec('id -u').to_i
+            sudo = 'sudo' unless 0 == executor.exec('id -u').to_i
             suffix = executor.exec('date \'+%Y%m%d%H%M\'') # use remote - not local - time machine
             executor.exec("[ -e \"#{remote_filename}\" ] && [ ! -h \"#{remote_filename}\" ] && #{sudo} mv -i \"#{remote_filename}\" \"#{remote_filename}.pre\"")
-            executor.exec("#{sudo} tee #{remote_filename}.#{suffix} > /dev/null", render(env, executor))
+            executor.exec("#{sudo} tee #{remote_filename}.#{suffix} > /dev/null", stdin: render(env, executor))
             executor.exec("#{sudo} ln -snf \"#{remote_filename}.#{suffix}\" \"#{remote_filename}\"")
+            shell = executor.exec('ps -p $$ -ocomm=')
+            env = { 'INSTALL_FILE' => remote_filename }
+            env_string = env.inject([]) { |a, b| a << b.map(&:shellescape).join('=') }.join(' ')
+            @postcmds.each do |cmd|
+                executor.exec("#{sudo} #{'env' if shell =~ /csh\z/} #{env_string} sh -c '#{cmd}'") # TODO: escape single quotes in cmd?
+            end
             executor.close
         end
 
@@ -94,15 +106,7 @@ module Cindy
 private
 
         def executor_for_env(env)
-            uri = URI.parse(env.uri)
-            case uri.scheme
-                when nil, 'file'
-                    Executor::Local.new
-                when 'ssh'
-                    Executor::SSH.new Net::SSH.start(uri.host, uri.user)
-                else
-                    raise Exception.new 'Unexpected protocol'
-            end
+            Executor::Base.from_uri env.uri, @owner.logger
         end
 
         def render(env, executor = nil)

data/lib/cindy/version.rb

@@ -1,3 +1,3 @@
 module Cindy
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
 end

data/test/test_cindy.rb

@@ -1,9 +1,20 @@
+require 'logger'
 require 'minitest_helper'
 
 class CindyTest < Minitest::Test
 
-    def test_true
-        assert true
+    def test_deploy
+        cindy = Cindy::Cindy.from_string <<-EOS
+            environment :foo, 'file:///'
+
+            template :bar, '#{File.join(__dir__, 'templates', 'deploy.tpl')}' do
+                on :foo, '/tmp/#{$$}'
+            end
+        EOS
+        cindy.logger = Logger.new File.open('/dev/null', File::WRONLY)
+
+        cindy.template_environment_deploy :foo, :bar
+        assert File.symlink?("/tmp/#{$$}")
     end
 
 end

data/test/test_local_executor.rb

@@ -0,0 +1,27 @@
+require 'logger'
+require 'minitest_helper'
+
+class LocalExecutorTest < Minitest::Test
+
+    def test_local_executor
+        logger = Logger.new File.open('/dev/null', File::WRONLY)
+        locexec = Cindy::Executor::Local.new nil, logger
+        # unknown command
+        assert_raises Cindy::Executor::CommandFailedError do
+            locexec.exec "eko foo"
+        end
+        assert_equal '', locexec.exec("eko foo", ignore_failure: true)
+        assert !locexec.exec("eko foo", ignore_failure: true, check_status_only: true)
+        # command failure
+        assert_raises Cindy::Executor::CommandFailedError do
+            locexec.exec 'grep -q foo', stdin: 'bar'
+        end
+        assert_equal '', locexec.exec("grep -q foo", stdin: 'bar', ignore_failure: true)
+        assert !locexec.exec("grep -q foo", stdin: 'bar', ignore_failure: true, check_status_only: true)
+        # valid command
+        assert_equal 'foo', locexec.exec('echo foo')
+        assert_equal 'foo', locexec.exec('echo foo', ignore_failure: true)
+        assert locexec.exec('echo foo', ignore_failure: true, check_status_only: true)
+    end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cindy-cm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - julp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-10 00:00:00.000000000 Z
+date: 2015-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -84,14 +84,17 @@ files:
 - lib/cindy/cli.rb
 - lib/cindy/command.rb
 - lib/cindy/environment.rb
+- lib/cindy/executor/base.rb
 - lib/cindy/executor/local.rb
 - lib/cindy/executor/ssh.rb
 - lib/cindy/template.rb
 - lib/cindy/variable.rb
 - lib/cindy/version.rb
 - test/minitest_helper.rb
+- test/templates/deploy.tpl
 - test/test_cindy.rb
 - test/test_dsl.rb
+- test/test_local_executor.rb
 homepage: https://github.com/julp/cindy
 licenses:
 - BSD
@@ -112,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Turn out your configuration files into ERB templates and deploy them