upstart-exporter 2.1.2 → 2.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dee17e8ba6b4e4ab976d7ae3ecc16f171829c914
+  data.tar.gz: 732bf68bdcaded54a5daa625f93ebb1af8fdc7cf
+SHA512:
+  metadata.gz: f13d22de2f4d5e595be058ffefc448bd30514813114676c60e3ff44277432014d969d0f4065b36860e0460270b4fe796e325bbf418edd6795197cdfb83753d54
+  data.tar.gz: 708f2bab35e591f91697bd8512ab76a54c3cf9b8ccc878f81b68b6e4f15c81574cf756d345c9bcb655bb1481fd423ac3c0a45349c45141bf20dff976731a139c

data/.gitignore

@@ -3,3 +3,5 @@
 Gemfile.lock
 pkg/*
 *.sw?
+test.yaml
+temp/*

data/Gemfile

@@ -5,5 +5,5 @@ gem 'rake'
 gem 'yard'
 gem 'safe_yaml'
 
-gem 'rspec'
-gem 'fakefs', :require => 'fakefs/safe'
+gem 'rspec', '>= 2.0'
+gem 'fakefs', '~> 0.5.0', :require => 'fakefs/safe'

data/README.md

@@ -1,16 +1,20 @@
-Gem for exporting user-scripts as Upstart scripts
-====================
+Safely generate Upstart jobs from Procfiles
+===========================================
 
 [![Build Status](https://secure.travis-ci.org/funbox/upstart-exporter.png)](http://travis-ci.org/funbox/upstart-exporter)
 
 Purpose
 -------
 
-It is often neccessary to run some supporting background tasks for rails projects alongside with the webserver. One of the solutions is use of Foreman gem, which allows to export tasks as Upstart scripts. This solution is dangerous, because it requires root priveleges for foreman executable (in order to add scripts to /etc/init), so it allows the exporting user to run any code as root (by placing appropriate script into /etc/init).
+It is often necessary to run some supporting background tasks for rails projects alongside with the web server.
+One of the solutions is the use of Foreman gem, which allows exporting tasks as Upstart scripts.
+This solution is dangerous, because it requires root privileges for foreman executable (in order to add scripts to `/etc/init`),
+so it allows the exporting user to run any code as root (by placing appropriate script into `/etc/init`).
 
-This gem is an attempt to provide a safe way for installing backround jobs, so that they run under some fixed user without root priveleges.
+This gem is an attempt to provide a safe way for installing background jobs, so that they run under some fixed user
+without root privileges.
 
-The only interface to the gem that should be used is the script(*upstart-export*) it provides.
+The only interface to the gem that should be used is the `upstart-export` script it provides.
 
 Installing
 ----------
@@ -21,14 +25,18 @@ Installing
 Configuration
 -------------
 
-The export process is configured through the only config, /etc/upstart-exporter.yaml, which is a simple YAML file of the following format:
+The export process is configured through the only config, `/etc/upstart-exporter.yaml`,
+which is a simple YAML file of the following format:
 
     ---
     run_user: www # The user under which all installed through upstart-exporter background jobs are run
     run_group: www # The group of run_user
-    helper_dir: /var/helper_dir # Auxilary directory for scripts incapsulating background jobs
+    helper_dir: /var/helper_dir # Auxiliary directory for scripts incapsulating background jobs
     upstart_dir: /var/upstart_dir # Directory where upstart scripts should be placed
     prefix: 'myupstartjobs-' # Prefix added to app's log folders and upstart scripts
+    respawn: # Controls how often job can fail and be restarted, set to false to prohibit restart after failure
+      limit: 10 # Number of allowed restarts in given interval
+      interval: 10 # Interval in seconds
 
 The config is not installed by default. If this config is absent, the default values are the following:
 
@@ -36,8 +44,11 @@ The config is not installed by default. If this config is absent, the default va
     upstart_dir: /etc/init/
     run_user: service
     prefix: 'fb-'
+    respawn:
+      limit: 5
+      interval: 10
 
-To give a certain user (i.e. deployuser) ability to use this script, you can place the following lines into sudoers file:
+To give a certain user (i.e. `deployuser`) the ability to use this script, you can place the following lines into `sudoers` file:
 
     # Commands required for manipulating jobs
     Cmnd_Alias UPSTART = /sbin/start, /sbin/stop, /sbin/restart
@@ -57,19 +68,20 @@ To give a certain user (i.e. deployuser) ability to use this script, you can pla
 Usage
 -----
 
-Gem is able to process two versions of Procfile's, format of the Procfile is
-defined in the _version_ key. If the key is not present or is not equal to _2_
+Gem is able to process two versions of Procfiles, format of the Procfile is
+defined in the `version` key. If the key is not present or is not equal to `2`
 gem will try to parse it as Procfile v.1.
 
 Procfile v.1
 ------------
 
-After upstart-exporter is installed and configured, you may export background jobs from an arbitrary Procfile-like file of the following format:
+After upstart-exporter is installed and configured, you may export background jobs
+from an arbitrary Procfile-like file of the following format:
 
     cmdlabel1: cmd1
     cmdlabel2: cmd2
 
-i.e. a file ./myprocfile containing:
+i.e. a file `./myprocfile` containing:
 
     my_tail_cmd: /usr/bin/tail -F /var/log/messages
     my_another_tail_cmd: /usr/bin/tail -F /var/log/messages
@@ -88,7 +100,7 @@ look like this:
     env:
       RAILS_ENV: production
       TEST: true
-    working_directory: /srv/projects/mpro/current
+    working_directory: /srv/projects/my_website/current
     commands:
       my_tail_cmd:
         command: /usr/bin/tail -F /var/log/messages
@@ -100,58 +112,69 @@ look like this:
         working_directory: '/var/...' # if needs to be redefined
       my_another_tail_cmd:
         command: /usr/bin/tail -F /var/log/messages
+        kill_timeout: 60
         respawn: false # by default respawn option is enabled
       my_one_another_tail_cmd:
         command: /usr/bin/tail -F /var/log/messages
+        log: /var/log/messages_copy
       my_multi_tail_cmd:
         command: /usr/bin/tail -F /var/log/messages
         count: 2
 
-*start_on_runlevel* and *stop_on_runlevel* are two global options that can't be
-redefined. For more information on these options look into [upstart scripts documentation.]( http://upstart.ubuntu.com/cookbook/#start-on)
+`start_on_runlevel` and `stop_on_runlevel` are two global options that can't be
+redefined. For more information on these options look into
+[upstart scripts documentation](http://upstart.ubuntu.com/cookbook/#start-on).
 
-*working_directory* will generate the next line:
+`working_directory` will generate the following line:
 
     cd 'your/working/directory' && your_command
 
-*env* params can be redefined and extended in per-command options. Note, that
-you can't remove globally defined *env* variable.
-For given earlier Procfile example the generated command will look like:
+`env` params can be redefined and extended in per-command options. Note that
+you can't remove a globally defined `env` variable.
+For Procfile example given earlier the generated command will look like:
 
     env RAILS_ENV=staging TEST=true your_command
 
-*respawn* option controls restarting of scripts in case of their failure.
+`log` option lets you override the default log location (`/var/log/fb-my_website/my_one_another_tail_cmd.log`).
+
+`kill_timeout` option lets you override the default process kill timeout of 30 seconds.
+
+`respawn` option controls restarting of scripts in case of their failure.
 By default this option is enabled. For
-more info look into [documentation](http://upstart.ubuntu.com/cookbook/#respawn)).
+more info look into [documentation](http://upstart.ubuntu.com/cookbook/#respawn).
 
-*respawn_limit* option controls how often job can fail. If the job restarts more
-often than *count* times in *interval*, it won't be restarted anymore. For more
+`respawn_limit` option controls how often the job can fail. If the job restarts more
+often than `count` times in `interval`, it won't be restarted anymore. For more
 info look into [documentation](http://upstart.ubuntu.com/cookbook/#respawn-limit).
 
-Options *working_directory*, *env*, *respawn* and *respawn_limit* can be
+Options `working_directory`, `env`, `log`, `respawn` and `respawn_limit` can be
 defined both as global and as per-command options.
 
 Exporting
 ---------
 
-To export Procfile you should run
+To export a Procfile you should run
 
     sudo upstart-export -p ./myprocfile -n myapp
 
-where _myapp_ is the application name. This name only affects the names of generated files. For security purposes, app name is also allowed to contain only letters, digits and underscores. Assuming that default options are used, the following files and folders will be generated:
+where `myapp` is the application name.
+This name only affects the names of generated files.
+For security purposes, app name is also allowed to contain only letters, digits and underscores.
+Assuming that default options are used, the following files and folders will be generated:
 
-in /etc/init/:
+in `/etc/init/`:
 
     fb-myapp-my_another_tail_cmd.conf
     fb-myapp-my_tail_cmd.conf
     fb-myapp.conf
 
-in /var/local/upstart\_helpers/:
+in `/var/local/upstart_helpers/`:
 
     fb-myapp-my_another_tail_cmd.sh
     fb-myapp-my_tail_cmd.sh
 
-Prefix 'fb-' (which can be customised through config) is added to avoid collisions with other upstart jobs. After this my\_tail\_cmd, for example, will be able to be started as an upstart script:
+Prefix `fb-` (which can be customised through config) is added to avoid collisions with other upstart jobs.
+After this `my_tail_cmd`, for example, will be able to be started as an Upstart job:
 
     sudo start fb-myapp-my_tail_cmd
 
@@ -159,7 +182,7 @@ Prefix 'fb-' (which can be customised through config) is added to avoid collisio
 
     sudo stop fb-myapp-my_tail_cmd
 
-It's stdout/stderr will be redirected to /var/log/fb-myapp/my\_tail\_cmd.log.
+Its stdout/stderr will be redirected to `/var/log/fb-myapp/my_tail_cmd.log`.
 
 To start/stop all application commands at once, you can run:
 
@@ -172,4 +195,3 @@ To remove upstart scripts and helpers for a particular application you can run
     sudo upstart-export -c -n myapp
 
 The logs are not cleared in this case. Also, all old application scripts are cleared before each export.
-

data/lib/upstart-exporter.rb

@@ -4,8 +4,10 @@ require 'upstart-exporter/errors'
 require 'upstart-exporter/templates'
 require 'upstart-exporter/exporter_helpers'
 require 'upstart-exporter/expanded_exporter'
+require 'upstart-exporter/hash_utils'
 require 'upstart-exporter/options/global'
 require 'upstart-exporter/options/command_line'
+require 'upstart-exporter/options/validator'
 
 module Upstart
   class Exporter
@@ -17,17 +19,20 @@ module Upstart
     def initialize(command_line_args)
       global_options = Options::Global.new
       command_line_options = Options::CommandLine.new(command_line_args)
+
       @options = global_options.merge(command_line_options)
+      Upstart::Exporter::Options::Validator.new(@options).validate!
+
       ensure_dirs
     end
 
     def export
       clear
       export_app
-      if options[:commands]['version'] && options[:commands]['version'] == 2
+      if options[:procfile_commands][:version] && options[:procfile_commands][:version] == 2
         ExpandedExporter.export(options)
       else
-        options[:commands].each do |cmd_name, cmd|
+        options[:procfile_commands].each do |cmd_name, cmd|
           export_command(cmd_name, cmd)
         end
       end
@@ -46,12 +51,12 @@ module Upstart
     protected
 
     def start_on_runlevel
-      lvl = options[:commands]['start_on_runlevel'] || options[:start_on_runlevel]
+      lvl = options[:procfile_commands][:start_on_runlevel] || options[:start_on_runlevel]
       "runlevel #{lvl}"
     end
 
     def stop_on_runlevel
-      lvl = options[:commands]['stop_on_runlevel'] || options[:stop_on_runlevel]
+      lvl = options[:procfile_commands][:stop_on_runlevel] || options[:stop_on_runlevel]
       "runlevel #{lvl}"
     end
 
@@ -87,8 +92,8 @@ module Upstart
         :app_name => app_name,
         :start_on => "starting #{app_name}",
         :stop_on => "stopping #{app_name}",
-        :respawn => 'respawn',
-        :respawn_limit => '',
+        :respawn => respawn,
+        :respawn_limit => respawn_limit,
         :kill_timeout => options[:kill_timeout],
         :run_user => options[:run_user],
         :run_group => options[:run_group],
@@ -100,6 +105,16 @@ module Upstart
       end
     end
 
+    def respawn
+      options[:respawn] ? 'respawn' : ''
+    end
+
+    def respawn_limit
+      limits = options[:respawn]
+      return unless limits
+      "respawn limit #{limits[:count].to_i} #{limits[:interval].to_i}"
+    end
+
     def export_command(cmd_name, cmd)
       export_cmd_helper(cmd_name, cmd)
       export_cmd_upstart_conf(cmd_name)

data/lib/upstart-exporter/expanded_exporter.rb

@@ -8,15 +8,15 @@ class Upstart::Exporter
     end
 
     def initialize(options)
-      @config = options[:commands]
       @options = options
-      @commands = @config['commands']
-      @env = @config['env'] || {}
+      @procfile_commands = options[:procfile_commands]
+      @commands = @procfile_commands[:commands]
+      @env = @procfile_commands[:env] || {}
     end
 
     def export
       @commands.each do |command, cmd_options|
-        if count = cmd_options['count']
+        if count = cmd_options[:count]
           count.times do |counter|
             export_cmd("#{command}_#{counter}", cmd_options)
           end
@@ -30,12 +30,12 @@ class Upstart::Exporter
 
     def export_cmd(command, cmd_options)
       cmd_options = {
-        'working_directory' => working_directory(cmd_options),
-        'log' => log(cmd_options),
-        'kill_timeout' => kill_timeout(cmd_options)
+        :working_directory => working_directory(cmd_options),
+        :log => log(cmd_options),
+        :kill_timeout => kill_timeout(cmd_options)
       }.merge(cmd_options)
 
-      script = cmd_options['command']
+      script = cmd_options[:command]
       script = add_env_command(script, cmd_options)
       script = add_dir_command(script, cmd_options)
       script = add_log_command(script, cmd_options)
@@ -46,7 +46,7 @@ class Upstart::Exporter
 
     def add_env_command(script, command)
       vars = ''
-      env = @env.merge((command['env'] || {}))
+      env = @env.merge((command[:env] || {}))
       env.each do |var, val|
         vars += "#{var}=#{val} "
       end
@@ -58,7 +58,7 @@ class Upstart::Exporter
     end
 
     def add_dir_command(script, command)
-      dir = command['working_directory']
+      dir = command[:working_directory]
       if dir.empty?
         script
       else
@@ -67,7 +67,7 @@ class Upstart::Exporter
     end
 
     def add_log_command(script, command)
-      log = command['log']
+      log = command[:log]
       if log.empty?
         script
       else
@@ -75,24 +75,14 @@ class Upstart::Exporter
       end
     end
 
-    def respawn_options(cmd_options)
-      if cmd_options.has_key?('respawn')
-        cmd_options['respawn']
-      elsif @config.has_key?('respawn')
-        @config['respawn']
-      else
-        {}
-      end
-    end
-
     def respawn(cmd_options)
       respawn_options(cmd_options) ? 'respawn' : ''
     end
 
     def respawn_limit(cmd_options)
       limits = respawn_options(cmd_options)
-      return '' unless limits && limits['count'] && limits['interval']
-      "respawn limit #{limits['count'].to_i} #{limits['interval'].to_i}"
+      return '' unless limits && limits[:count] && limits[:interval]
+      "respawn limit #{limits[:count].to_i} #{limits[:interval].to_i}"
     end
 
     def start_on
@@ -103,16 +93,20 @@ class Upstart::Exporter
       "stopping #{app_name}"
     end
 
+    def respawn_options(cmd_options)
+      command_option(cmd_options, :respawn)
+    end
+
     def working_directory(cmd_options)
-      command_option(cmd_options, 'working_directory')
+      command_option(cmd_options, :working_directory)
     end
 
     def log(cmd_options)
-      command_option(cmd_options, 'log')
+      command_option(cmd_options, :log)
     end
 
     def kill_timeout(cmd_options)
-      command_option(cmd_options, 'kill_timeout')
+      command_option(cmd_options, :kill_timeout)
     end
 
     def export_cmd_upstart_conf(cmd_name, cmd_options)
@@ -136,7 +130,11 @@ class Upstart::Exporter
     private
 
     def command_option(cmd_options, key)
-      cmd_options[key.to_s] || @config[key.to_s] || @options[key.to_sym] || ''
+      extract_options(cmd_options[key], @procfile_commands[key], @options[key], '')
+    end
+
+    def extract_options(*array)
+      array.find { |v| !v.nil? }
     end
   end
 end

data/lib/upstart-exporter/hash_utils.rb

@@ -0,0 +1,22 @@
+module Upstart
+  class Exporter
+    class HashUtils
+
+      def self.symbolize_keys(obj)
+        case obj
+          when Hash
+            Hash[
+              obj.map do |key, value|
+                [key.respond_to?(:to_sym) ? key.to_sym : key, symbolize_keys(value)]
+              end
+            ]
+          when Array
+            obj.map {|value| symbolize_keys(value)}
+          else
+            obj
+        end
+      end
+
+    end
+  end
+end

data/lib/upstart-exporter/options/command_line.rb

@@ -4,11 +4,11 @@ module Upstart::Exporter::Options
 
     def initialize(command_line_args)
       super
-      self[:commands] = if command_line_args[:clear]
+      self[:procfile_commands] = if command_line_args[:clear]
         {}
-      else
+                        else
         process_procfile(command_line_args[:procfile])
-      end
+                        end
       self[:app_name] = process_appname(command_line_args[:app_name])
     end
 
@@ -32,9 +32,12 @@ module Upstart::Exporter::Options
         end
       end
       if commands['version'] && commands['version'].strip == '2'
-        commands = YAML.load(content)
-        error('procfile should include "commands" key') unless commands['commands']
-        error('command names should include only letters and/or underscores') if commands['commands'].keys.find { |k| k !~ /\A[A-z\d_]*?\z/ }
+        commands = Upstart::Exporter::HashUtils::symbolize_keys(YAML.load(content))
+        error('procfile should include "commands" key') unless commands[:commands]
+
+        if invalid_name = commands[:commands].keys.find {|k| k.to_s !~ /\A[A-z\d_]*?\z/}
+          error("command name #{invalid_name} should include only letters and/or underscores")
+        end
       end
       commands
     end

data/lib/upstart-exporter/options/global.rb

@@ -3,14 +3,18 @@ module Upstart::Exporter::Options
     include Upstart::Exporter::Errors
 
     DEFAULTS = {
-      'helper_dir' => '/var/local/upstart_helpers/',
-      'upstart_dir' => '/etc/init/',
-      'run_user' => 'service',
-      'run_group' => 'service',
-      'prefix' => 'fb-',
-      'start_on_runlevel' => '[3]',
-      'stop_on_runlevel' => '[3]',
-      'kill_timeout' => 30
+      :helper_dir => '/var/local/upstart_helpers/',
+      :upstart_dir => '/etc/init/',
+      :run_user => 'service',
+      :run_group => 'service',
+      :prefix => 'fb-',
+      :start_on_runlevel => '[3]',
+      :stop_on_runlevel => '[3]',
+      :kill_timeout => 30,
+      :respawn => {
+        :count => 5,
+        :interval => 10
+      }
     }
 
     CONF = '/etc/upstart-exporter.yaml'
@@ -18,11 +22,12 @@ module Upstart::Exporter::Options
     def initialize
       super
       config = if FileTest.file?(CONF)
-        YAML::load(File.read(CONF))
+        Upstart::Exporter::HashUtils.symbolize_keys(YAML::load(File.read(CONF)))
       else
         $stderr.puts "#{CONF} not found"
         {}
       end
+
       error "#{CONF} is not a valid YAML config" unless config.is_a?(Hash)
       DEFAULTS.keys.each do |param|
         value = if config[param]

data/lib/upstart-exporter/options/validator.rb

@@ -0,0 +1,78 @@
+module Upstart::Exporter::Options
+  class Validator
+
+    include Upstart::Exporter::Errors
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def validate!
+      validate_path(options[:helper_dir])
+      validate_path(options[:upstart_dir])
+
+      reject_special_symbols(options[:run_user])
+      reject_special_symbols(options[:run_group])
+      reject_special_symbols(options[:prefix])
+
+      validate_runlevel(options[:start_on_runlevel])
+      validate_runlevel(options[:stop_on_runlevel])
+
+      validate_digits(options[:kill_timeout])
+
+      validate_respawn(options[:respawn])
+
+      if options[:procfile_commands][:version] == 2
+        validate_procfile_v2(options[:procfile_commands])
+      end
+    end
+
+    private
+
+      def validate_procfile_v2(config)
+        validate_command_params(config)
+        config[:commands].values.each {|cmd| validate_command_params(cmd)}
+      end
+
+      def validate_command_params(cmd)
+        validate_runlevel(cmd[:start_on_runlevel])
+        validate_runlevel(cmd[:stop_on_runlevel])
+        validate_path(cmd[:working_directory])
+        validate_respawn(cmd[:respawn])
+      end
+
+      def validate_respawn(options)
+        return unless options
+        validate_digits(options[:kill_timeout])
+        validate_digits(options[:interval])
+      end
+
+      def validate_path(val)
+        validate(val, /\A[A-Za-z0-9_\-.\/]+\z/)
+      end
+
+      def reject_special_symbols(val)
+        validate(val, /\A[A-Za-z0-9_\-]+\z/)
+      end
+
+      def validate_runlevel(val)
+        validate(val, /\A\[\d+\]\z/)
+      end
+
+      def validate_digits(val)
+        validate(val, /\A\d+\z/)
+      end
+
+      def validate(val, regexp)
+        val = val.to_s
+        return if val == ""
+
+        unless val =~ regexp
+          error("value #{val} is insecure and can't be accepted")
+        end
+      end
+
+  end
+end

data/lib/upstart-exporter/templates.rb

@@ -8,16 +8,10 @@ module Upstart
       end
 
       def self.app(binds)
-        if error_val = binds.find { |v| v =~ /\A[A-z0-9_\- ]*?\z/ }
-          error("value #{error_val} is insecure and can't be accepted")
-        end
         interpolate(APP_TPL, binds)
       end
 
       def self.command(binds)
-        if error_val = binds.find { |v| v =~ /\A[A-z0-9_\- ]*?\z/ }
-          error("value #{error_val} is insecure and can't be accepted")
-        end
         interpolate(COMMAND_TPL, binds)
       end
 

data/lib/upstart-exporter/version.rb

@@ -1,5 +1,5 @@
 module Upstart
   class Exporter
-    VERSION = "2.1.2"
+    VERSION = "2.1.3"
   end
 end

data/spec/lib/upstart-exporter/errors_spec.rb

@@ -7,7 +7,7 @@ describe Upstart::Exporter::Errors do
         include Upstart::Exporter::Errors
       end
 
-      Foo.new.should respond_to(:error)
+      expect(Foo.new).to respond_to(:error)
     end
   end
 
@@ -17,7 +17,7 @@ describe Upstart::Exporter::Errors do
         include Upstart::Exporter::Errors
       end
 
-      lambda{ Foo.new.error("arrgh") }.should raise_exception(Upstart::Exporter::Error)
+      expect{ Foo.new.error("arrgh") }.to raise_exception(Upstart::Exporter::Error)
     end
   end
 end

data/spec/lib/upstart-exporter/expanded_exporter_spec.rb

@@ -7,21 +7,21 @@ describe Upstart::Exporter::ExpandedExporter do
       @defaults[key.to_sym] = value
     end
 
-    File.stub(:open)
+    allow(File).to receive(:open)
   end
 
   it 'calls template render exact amount of times' do
-    Upstart::Exporter::Templates.should_receive(:command).exactly(5).times
+    expect(Upstart::Exporter::Templates).to receive(:command).exactly(5).times
     options = {
-      :commands => {
-        'commands' => {
-          'ls' => {
-            'command' => 'ls',
-            'count' => 3
+      :procfile_commands => {
+        :commands => {
+          :ls => {
+            :command => 'ls',
+            :count => 3
           },
-          'ls2' => {
-            'command' => 'ls',
-            'count' => 2
+          :ls2 => {
+            :command => 'ls',
+            :count => 2
           }
         }
       },
@@ -32,21 +32,21 @@ describe Upstart::Exporter::ExpandedExporter do
   end
 
   it 'merges env params in the right order' do
-    Upstart::Exporter::Templates.should_receive(:helper) do |options|
-      options[:cmd].should include('B=b')
-      options[:cmd].should include('T=t')
+    expect(Upstart::Exporter::Templates).to receive(:helper) do |options|
+      expect(options[:cmd]).to include('B=b')
+      expect(options[:cmd]).to include('T=t')
     end
     options = {
-      :commands => {
-        'env' => {
-          'T' => 't',
-          'B' => 'a'
+      :procfile_commands => {
+        :env => {
+          :T => 't',
+          :B => 'a'
         },
-        'commands' => {
-          'ls' => {
-            'command' => 'ls',
-            'env' => {
-              'B' => 'b'
+        :commands => {
+          :ls => {
+            :command => 'ls',
+            :env => {
+              :B => 'b'
             }
           }
         }
@@ -63,38 +63,38 @@ describe Upstart::Exporter::ExpandedExporter do
       :app_name => 'appname',
       :working_directory => "/",
       :log => "public.log",
-      :commands => {
-        'working_directory' => '/var/log',
-        'commands' => {
-          'rm1' => {
-            'command' => 'rm *',
-            'log' => 'private.log'
+      :procfile_commands => {
+        :working_directory => '/var/log',
+        :commands => {
+          :rm1 => {
+            :command => 'rm *',
+            :log => 'private.log'
           },
-          'rm2' => {
-            'command' => 'rm -rf *',
-            'working_directory' => '/home'
+          :rm2 => {
+            :command => 'rm -rf *',
+            :working_directory => '/home'
           },
-          'rm3' => {
-            'command' => 'rm -f vmlinuz',
+          :rm3 => {
+            :command => 'rm -f vmlinuz',
           }
         }
       }
     }.merge(@defaults)
-    Upstart::Exporter::Templates.should_receive(:helper) do |options|
-      options.should include('working_directory' => '/var/log') # propagated from 'commands'
-      options.should include('log' => 'private.log')            # redefined by command
-      options.should include(:cmd => "cd '/var/log' && exec rm * >> private.log 2>&1")
-    end
-    Upstart::Exporter::Templates.should_receive(:helper) do |options|
-      options.should include('working_directory' => '/home')    # redefined by command
-      options.should include('log' => 'public.log')             # propagated from the very top level
-      options.should include(:cmd => "cd '/home' && exec rm -rf * >> public.log 2>&1")
-    end
-    Upstart::Exporter::Templates.should_receive(:helper) do |options|
-      options.should include('working_directory' => '/var/log') # propagated from 'commands'
-      options.should include('log' => 'public.log')             # propagated from the very top level
-      options.should include(:cmd => "cd '/var/log' && exec rm -f vmlinuz >> public.log 2>&1")
-    end
+    expect(Upstart::Exporter::Templates).to receive(:helper).with(hash_including(
+      :working_directory => "/var/log",
+      :log => "private.log",
+      :cmd=> "cd '/var/log' && exec rm * >> private.log 2>&1"
+    ))
+    expect(Upstart::Exporter::Templates).to receive(:helper).with(hash_including(
+      :working_directory =>"/home",
+      :log => "public.log",
+      :cmd => "cd '/home' && exec rm -rf * >> public.log 2>&1"
+    ))
+    expect(Upstart::Exporter::Templates).to receive(:helper).with(hash_including(
+      :working_directory =>"/var/log",
+      :log => "public.log",
+      :cmd => "cd '/var/log' && exec rm -f vmlinuz >> public.log 2>&1"
+    ))
     described_class.export(options)
   end
 end

data/spec/lib/upstart-exporter/options/command_line_spec.rb

@@ -4,68 +4,67 @@ describe Upstart::Exporter::Options::CommandLine do
   context "when correct options are given" do
     it "should give access to options like a hash" do
         make_procfile('Procfile', 'ls_cmd: ls')
-        described_class.new(:app_name => 'someappname', :procfile => 'Procfile').should respond_to('[]')
+        expect(described_class.new(:app_name => 'someappname', :procfile => 'Procfile')).to respond_to('[]')
     end
 
     it "should parse procfile" do
         make_procfile('Procfile', 'ls_cmd: ls')
         options = described_class.new(:app_name => 'someappname', :procfile => 'Procfile')
-        options[:commands].should == {'ls_cmd' => ' ls'}
+        expect(options[:procfile_commands]).to eq({'ls_cmd' => ' ls'})
     end
 
     it 'should parse procfile v2' do
         make_procfile('Procfile', "version: 2\ncommands:\n  ls:\n    command: ls -al")
         options = described_class.new(:app_name => 'someappname', :procfile => 'Procfile')
-        options[:commands].should have_key('commands')
-        options[:commands]['commands'].should have_key('ls')
+        expect(options[:procfile_commands]).to have_key(:commands)
+        expect(options[:procfile_commands][:commands]).to have_key(:ls)
     end
 
     it "should skip empty and commented lines in a procfile" do
         make_procfile('Procfile', "ls_cmd1: ls1\n\nls_cmd2: ls2\n # fooo baaar")
         options = described_class.new(:app_name => 'someappname', :procfile => 'Procfile')
-        options[:commands].should == {'ls_cmd1' => ' ls1', 'ls_cmd2' => ' ls2'}
+        expect(options[:procfile_commands]).to eq({'ls_cmd1' => ' ls1', 'ls_cmd2' => ' ls2'})
     end
 
     it "should store app_name" do
         make_procfile('Procfile', "ls_cmd1: ls1\n\nls_cmd2: ls2\n # fooo baaar")
         options = described_class.new(:app_name => 'someappname', :procfile => 'Procfile')
-        options[:app_name].should == 'someappname'
+        expect(options[:app_name]).to eq('someappname')
     end
 
     it "should not process procfile if :clear arg is present" do
         make_procfile('Procfile', "bad procfile")
         options = described_class.new(:app_name => 'someappname', :procfile => 'Procfile', :clear => true)
-        options[:app_name].should == 'someappname'
-        options[:commands].should == {}
+        expect(options[:app_name]).to eq('someappname')
+        expect(options[:procfile_commands]).to eq({})
     end
   end
 
   context "when bad app_name is passed" do
     it "should raise exception" do
       make_procfile('Procfile', 'ls_cmd: ls')
-      lambda{ described_class.new(:app_name => 'some appname', :procfile => 'Procfile') }.should raise_exception
-      lambda{ described_class.new(:app_name => '-someappname', :procfile => 'Procfile') }.should raise_exception
-      lambda{ described_class.new(:procfile => 'Procfile') }.should raise_exception
+      expect{ described_class.new(:app_name => 'some appname', :procfile => 'Procfile') }.to raise_exception
+      expect{ described_class.new(:app_name => '-someappname', :procfile => 'Procfile') }.to raise_exception
+      expect{ described_class.new(:procfile => 'Procfile') }.to raise_exception
     end
   end
 
   context "when bad Procfile is passed" do
     it "should raise exception" do
       make_procfile('Procfile', 'ls cmd: ls')
-      lambda{ described_class.new(:app_name => 'someappname', :procfile => 'Procfile') }.should raise_exception
+      expect{ described_class.new(:app_name => 'someappname', :procfile => 'Procfile') }.to raise_exception
 
       make_procfile('Procfile', '-lscmd: ls')
-      lambda{ described_class.new(:app_name => 'someappname', :procfile => 'Procfile') }.should raise_exception
+      expect{ described_class.new(:app_name => 'someappname', :procfile => 'Procfile') }.to raise_exception
 
-      lambda{ described_class.new(:app_name => 'someappname', :procfile => '::') }.should raise_exception
+      expect{ described_class.new(:app_name => 'someappname', :procfile => '::') }.to raise_exception
 
       make_procfile('Procfile', "version: 2\ncommands:\n  ls cmd:\n    command: ls")
-      lambda{ described_class.new(:app_name => 'someappname', :procfile => 'Procfile') }.should raise_exception
+      expect{ described_class.new(:app_name => 'someappname', :procfile => 'Procfile') }.to raise_exception
 
-      lambda{ described_class.new(:app_name => 'someappname') }.should raise_exception
+      expect{ described_class.new(:app_name => 'someappname') }.to raise_exception
     end
   end
 
-
 end
 

data/spec/lib/upstart-exporter/options/global_spec.rb

@@ -7,7 +7,7 @@ describe Upstart::Exporter::Options::Global do
 
   it "should give access to options like a hash" do
     capture(:stderr) do
-      described_class.new.should respond_to('[]')
+      expect(described_class.new).to respond_to('[]')
     end
   end
 
@@ -17,7 +17,7 @@ describe Upstart::Exporter::Options::Global do
       capture(:stderr) do
         options = described_class.new
         defaults.each do |option, default_value|
-          options[option.to_sym].should == default_value
+          expect(options[option.to_sym]).to eq(default_value)
         end
       end
     end
@@ -27,9 +27,9 @@ describe Upstart::Exporter::Options::Global do
   context "when invalid config is given" do
     it "should raise exception" do
       make_global_config('zxc')
-      lambda{described_class.new}.should raise_exception
+      expect{described_class.new}.to raise_exception
       make_global_config([123].to_yaml)
-      lambda{described_class.new}.should raise_exception
+      expect{described_class.new}.to raise_exception
     end
   end
 
@@ -37,14 +37,14 @@ describe Upstart::Exporter::Options::Global do
     it "should override default values" do
       capture(:stderr) do
         make_global_config({'run_user' => 'wwwww'}.to_yaml)
-        described_class.new[:run_user].should == 'wwwww'
+        expect(described_class.new[:run_user]).to eq('wwwww')
       end
     end
 
     it "should preserve default values for options not specified in the config" do
       capture(:stderr) do
         make_global_config({'run_user' => 'wwwww'}.to_yaml)
-        described_class.new[:prefix] == defaults['prefix']
+        described_class.new[:prefix] == defaults[:prefix]
       end
     end
   end

data/spec/lib/upstart-exporter/options/validator_spec.rb

@@ -0,0 +1,42 @@
+require 'spec/spec_helper'
+
+describe Upstart::Exporter::Options::Validator do
+
+  it "validates paths" do
+    validator = described_class.new(:helper_dir => "/some/dir;")
+    expect {validator.validate!}.to raise_error(Upstart::Exporter::Error)
+  end
+
+  it "validates user names" do
+    validator = described_class.new(:run_user => "bad_user_name!")
+    expect {validator.validate!}.to raise_error(Upstart::Exporter::Error)
+  end
+
+  it "validates runlevels" do
+    validator = described_class.new(:start_on_runlevel => "[not_a_digit]")
+    expect {validator.validate!}.to raise_error(Upstart::Exporter::Error)
+  end
+
+  describe "procfile v2" do
+    it "validates respawn" do
+      options = {:procfile_commands => {:version => 2, :respawn => {:kill_timeout => "10;"}}}
+      validator = described_class.new(options)
+      expect {validator.validate!}.to raise_error(Upstart::Exporter::Error)
+    end
+
+    it "validates options for individual commands" do
+      options = {
+        :procfile_commands => {:version => 2,
+          :commands => {
+            :come_cmd => {
+              :working_directory => "!!!wrong_working-directory"
+            }
+          }
+        }
+      }
+      validator = described_class.new(options)
+      expect {validator.validate!}.to raise_error(Upstart::Exporter::Error)
+    end
+  end
+
+end

data/spec/lib/upstart-exporter/templates_spec.rb

@@ -20,13 +20,13 @@ EOF
 end script
 HEREDOC
 
-      described_class.app(
+      expect(described_class.app(
         :run_user => 'SOMEUSER',
         :run_group => 'SOMEGROUP',
         :app_name => 'SOMEAPP',
         :start_on => '12',
         :stop_on => '13'
-      ).should == conf
+      )).to eq(conf)
     end
   end
 
@@ -41,7 +41,7 @@ HEREDOC
 SOME COMMAND
 HEREDOC
 
-      described_class.helper('cmd' => 'SOME COMMAND').should == conf
+      expect(described_class.helper('cmd' => 'SOME COMMAND')).to eq(conf)
     end
   end
 
@@ -65,7 +65,7 @@ script
 end script
 HEREDOC
 
-      described_class.command(:run_user => 'SOMEUSER',
+      expect(described_class.command(:run_user => 'SOMEUSER',
                               :run_group => 'SOMEGROUP',
                               :app_name => 'SOMEAPP',
                               :cmd_name => 'SOMECMD',
@@ -74,7 +74,7 @@ HEREDOC
                               :start_on => 'starting SOMEAPP',
                               :stop_on => 'stopping SOMEAPP',
                               :kill_timeout => 24,
-                              :helper_cmd_conf => 'HELPERPATH').should == conf
+                              :helper_cmd_conf => 'HELPERPATH')).to eq(conf)
     end
   end
 

data/spec/lib/upstart-exporter_spec.rb

@@ -10,7 +10,11 @@ describe Upstart::Exporter do
       'run_user' => 'u',
       'run_group' => 'g',
       'prefix' => 'p-',
-      'start_on_runlevel' => '[7]'
+      'start_on_runlevel' => '[7]',
+      'respawn' => {
+        'count' => 7,
+        'interval' => 14
+      }
     }.to_yaml)
     make_procfile('Procfile', 'ls_cmd: ls')
   end
@@ -19,52 +23,78 @@ describe Upstart::Exporter do
     exporter = described_class.new({:app_name => 'app', :procfile => 'Procfile'})
   end
 
+  describe '#export v2' do
+    it 'should correctly set respawn option' do
+
+      yaml = <<-eos
+version: 2
+commands:
+  first_cmd:
+    command: ping 127.0.0.1
+    respawn:
+      count: 9
+      interval: 19
+  second_cmd:
+    command: ping 127.0.0.1
+    respawn: false
+  third_cmd:
+    command: ping 127.0.0.1
+      eos
+      make_procfile('Procfile', yaml)
+
+      exporter.export
+      expect(File.read('/u/p-app-first_cmd.conf')).to include("respawn\nrespawn limit 9 19")
+      expect(File.read('/u/p-app-second_cmd.conf')).not_to include("respawn")
+      expect(File.read('/u/p-app-third_cmd.conf')).to include("respawn\nrespawn limit 7 14")
+    end
+  end
+
   describe '#export' do
     it 'should make cleanup before export' do
-      exporter.should_receive(:clear)
+      expect(exporter).to receive(:clear)
       exporter.export
     end
 
     it 'should create upstart scripts, folders and sh helpers' do
       exporter.export
       %w{/h/p-app-ls_cmd.sh /u/p-app.conf /u/p-app-ls_cmd.conf}.each do |f|
-        FileTest.file?(f).should be_true
+        expect(FileTest.file?(f)).to eq(true)
       end
     end
 
     it 'created scripts, folders and sh helpers should have valid content' do
       exporter.export
 
-      File.read('/h/p-app-ls_cmd.sh').should == tpl.helper(:cmd => 'exec ls')
-      File.read('/u/p-app.conf').should == tpl.app(:run_user => 'u',
+      expect(File.read('/h/p-app-ls_cmd.sh')).to eq(tpl.helper(:cmd => 'exec ls'))
+      expect(File.read('/u/p-app.conf')).to eq(tpl.app(:run_user => 'u',
                                                    :run_group => 'g',
                                                    :app_name => 'p-app',
                                                    :start_on => 'runlevel [7]',
-                                                   :stop_on => 'runlevel [3]')
-      File.read('/u/p-app-ls_cmd.conf').should == tpl.command(:run_user => 'u',
+                                                   :stop_on => 'runlevel [3]'))
+      expect(File.read('/u/p-app-ls_cmd.conf')).to eq(tpl.command(:run_user => 'u',
                                                               :run_group => 'g',
                                                               :app_name => 'p-app',
                                                               :cmd_name => 'ls_cmd',
                                                               :start_on => 'starting p-app',
                                                               :stop_on => 'stopping p-app',
                                                               :respawn => 'respawn',
-                                                              :respawn_limit => '',
+                                                              :respawn_limit => 'respawn limit 7 14',
                                                               :kill_timeout => 30,
-                                                              :helper_cmd_conf => '/h/p-app-ls_cmd.sh')
+                                                              :helper_cmd_conf => '/h/p-app-ls_cmd.sh'))
     end
 
     it 'prepends with "env" command starts with env var assignment' do
       make_procfile('Procfile', 'sidekiq: RAILS_ENV=production sidekiq')
       exporter.export
 
-      File.read('/h/p-app-sidekiq.sh').should == tpl.helper(:cmd => 'exec env RAILS_ENV=production sidekiq')
+      expect(File.read('/h/p-app-sidekiq.sh')).to eq(tpl.helper(:cmd => 'exec env RAILS_ENV=production sidekiq'))
     end
 
     it 'call to "env" will not appear twice' do
       make_procfile('Procfile', 'sidekiq: env RAILS_ENV=production sidekiq')
       exporter.export
 
-      File.read('/h/p-app-sidekiq.sh').should == tpl.helper(:cmd => 'exec env RAILS_ENV=production sidekiq')
+      expect(File.read('/h/p-app-sidekiq.sh')).to eq(tpl.helper(:cmd => 'exec env RAILS_ENV=production sidekiq'))
     end
   end
 
@@ -72,8 +102,8 @@ describe Upstart::Exporter do
     it 'should remove exported app helpers an scripts' do
       exporter.export
       exporter.clear
-      Dir['/h/*'].should be_empty
-      Dir['/u/*'].should be_empty
+      expect(Dir['/h/*']).to be_empty
+      expect(Dir['/u/*']).to be_empty
     end
 
     it 'should keep files of other apps' do
@@ -86,7 +116,7 @@ describe Upstart::Exporter do
       exporter.clear
 
       %w{/h/p-other_app-ls_cmd.sh /u/p-other_app.conf /u/p-other_app-ls_cmd.conf}.each do |f|
-        FileTest.file?(f).should be_true
+        expect(FileTest.file?(f)).to eql true
       end
     end
   end

metadata

@@ -1,44 +1,33 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: upstart-exporter
-version: !ruby/object:Gem::Version 
-  hash: 15
-  prerelease: 
-  segments: 
-  - 2
-  - 1
-  - 2
-  version: 2.1.2
+version: !ruby/object:Gem::Version
+  version: 2.1.3
 platform: ruby
-authors: 
+authors:
 - Ilya Averyanov
 - Egor Blinov
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-02-24 00:00:00 +04:00
-default_executable: 
+date: 2016-02-04 00:00:00.000000000 Z
 dependencies: []
-
 description: Gem for converting extended Procfile-like files to upstart scripts
-email: 
+email:
 - ilya@averyanov.org
 - monshq@gmail.com
-executables: 
+executables:
 - upstart-export
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
-- .rbenv-version
-- .rspec
-- .ruby-version
-- .travis.yml
-- .yardoc/checksums
-- .yardoc/objects/root.dat
-- .yardoc/proxy_types
+files:
+- ".gitignore"
+- ".rbenv-version"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- ".yardoc/checksums"
+- ".yardoc/objects/root.dat"
+- ".yardoc/proxy_types"
 - Gemfile
 - README.md
 - Rakefile
@@ -70,14 +59,17 @@ files:
 - lib/upstart-exporter/errors.rb
 - lib/upstart-exporter/expanded_exporter.rb
 - lib/upstart-exporter/exporter_helpers.rb
+- lib/upstart-exporter/hash_utils.rb
 - lib/upstart-exporter/options/command_line.rb
 - lib/upstart-exporter/options/global.rb
+- lib/upstart-exporter/options/validator.rb
 - lib/upstart-exporter/templates.rb
 - lib/upstart-exporter/version.rb
 - spec/lib/upstart-exporter/errors_spec.rb
 - spec/lib/upstart-exporter/expanded_exporter_spec.rb
 - spec/lib/upstart-exporter/options/command_line_spec.rb
 - spec/lib/upstart-exporter/options/global_spec.rb
+- spec/lib/upstart-exporter/options/validator_spec.rb
 - spec/lib/upstart-exporter/templates_spec.rb
 - spec/lib/upstart-exporter_spec.rb
 - spec/spec_helper.rb
@@ -85,48 +77,39 @@ files:
 - spec/support/procfile.rb
 - spec/support/streams.rb
 - upstart-exporter.gemspec
-has_rdoc: true
-homepage: ""
+homepage: ''
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Gem for converting extended Procfile-like files to upstart scripts
-test_files: 
+test_files:
 - spec/lib/upstart-exporter/errors_spec.rb
 - spec/lib/upstart-exporter/expanded_exporter_spec.rb
 - spec/lib/upstart-exporter/options/command_line_spec.rb
 - spec/lib/upstart-exporter/options/global_spec.rb
+- spec/lib/upstart-exporter/options/validator_spec.rb
 - spec/lib/upstart-exporter/templates_spec.rb
 - spec/lib/upstart-exporter_spec.rb
 - spec/spec_helper.rb
 - spec/support/global_config.rb
 - spec/support/procfile.rb
 - spec/support/streams.rb
+has_rdoc: