baal 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9fd791002dfcce1998043d8c2933dfe4916f711f
+  data.tar.gz: 6eb46c2f1680ef7c4134452324139ad4589c4af1
+SHA512:
+  metadata.gz: 9242ed3fc57795d76a102afa72f3cd3eeb2d859461efcdea523109d4e8461ea216baac53137aeea4c57ce0fe5d2878b1075bede930dd77ac7015770bd09586fb
+  data.tar.gz: e70d24a8b3af1051f6af9cab25058b131969bb6b3d97ed6662f7fc35bcd7b23085e246e779aae1b7fe83bc94e6b4cc0d1536e0c9adbcdbbca9f12a0298c251ca

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.13.7

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Baal.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Lukas Nimmo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# Baal
+
+Baal is a Ruby wrapper for start-stop-daemon that attempts to make your start-stop-daemon scripts easier to build and
+read while still providing the same options you are used to. Baal, through start-stop-daemon, provides a myriad of ways
+to start new daemon processes and check the status of and stop existing ones.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'baal'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install baal
+
+## Usage
+
+The intention of Baal is to provide an easily-readable, step-by-step process of building start-stop-daemon scripts.
+
+The wrapper provides all methods you are used to and attempts to alert you (with a nice red error) if it notices a mistake.
+
+All building is centered around the Daemon object which can be accessed like so:
+
+```ruby
+# Preferred
+daemon = Baal.new
+
+# Not preferred
+daemon = Baal::Daemon.new
+```
+
+Once you have your builder object, it is simply a matter of constructing the needed commands and options.
+
+```ruby
+# Start a new process in the background
+daemon.start
+daemon.instance_of_exec('/abs/path/to/executable')
+daemon.with_name('dave')
+```
+
+Then execute what you have built
+
+```ruby
+daemon.daemonize!
+```
+
+You can even check the current status of what you are to execute
+
+```ruby
+puts daemon.execution
+```
+
+You can also clear the current contents of what you have built up
+
+```ruby
+# Begin with start
+daemon.start
+daemon.start_as('/path/to/file')
+daemon.pid_file('/path/to/pid_file')
+
+# Something came up! Need to clear it...
+daemon.clear_all!
+```
+
+
+All of the methods that build up your start-stop-daemon script are chain-able
+
+```ruby
+# Check the status of a process
+daemon.status.with_pid(1234).daemonize!
+```
+
+All options with dashes have been converted to underscores, ie.
+
+```ruby
+# From
+daemon.make-pidfile
+
+# To
+daemon.make_pidfile
+```
+ 
+and there are many methods that have been written to be more Ruby-like, however, if you still prefer the original
+command and option names (dashes are not allowed), those are available as well 
+
+```ruby
+# These are just options...
+daemon.start.start_as('/p/a/t/h').pid_file('/p/a/t/h').change_to_user('dave')
+
+# Original language
+daemon.start.startas('/p/a/t/h').pidfile('/p/a/t/h').chuid('dave')
+
+# No option for multi-word options with dashes
+daemon.make-pidfile # No method
+daemon.make_pidfile # As above
+```
+
+The documentation in the library should be enough, but if it isn't, or you just don't like my writing style, then there
+is the official [documention](https://manpages.debian.org/jessie/dpkg/start-stop-daemon.8.en.html) of start-stop-daemon.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/numbluk/baal.
+
+## License
+
+Copyright (c) 2017 Lukas Nimmo.
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/baal.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'baal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'baal'
+  spec.version       = Baal::VERSION
+  spec.authors       = ['Lukas Nimmo']
+  spec.email         = ['Lukas.nimmo@gmail.com']
+
+  spec.summary       = <<-HEREDOC
+    Baal is a Ruby wrapper for start-stop-daemon that attempts to make your start-stop-daemon scripts easier to build
+      and read while still providing the same options you are used to. Baal, through start-stop-daemon, provides a
+      myriad of ways to start new daemon processes and check the status of and stop existing ones.
+    HEREDOC
+  spec.homepage      = 'https://github.com/numbluk/baal'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry', '~> 3.0'
+end

data/lib/baal.rb

@@ -0,0 +1,75 @@
+require 'baal/version'
+require 'baal/commands'
+require 'baal/matching_options'
+require 'baal/optional_options'
+
+# The Baal module is the namespace containing all interaction with the Baal gem.
+# Very little is actually done directly on the Baal module. The primary
+# interaction with the Baal module itself will be the instantiation of a Daemon
+# object with the convenience method #new:
+#
+# 1. Baal.new
+#
+# vs
+#
+# 2. Baal::Daemon.new
+#
+module Baal
+  def self.new
+    Daemon.new
+  end
+
+  # Daemon is a builder object that allows you construct and access, at any
+  # time, the start-stop-daemon string that will be executed. All building
+  # of the start-stop-daemon string will be through this object.
+  #
+  # A note should be made that all methods which build the start-stop-daemon
+  # script return the Daemon instance for the intention of method chaining
+  # where possible so as to read like written English.
+  #
+  class Daemon
+    include Baal::Commands
+    include Baal::MatchingOptions
+    include Baal::OptionalOptions
+
+    PROGRAM_NAME = 'start-stop-daemon'.freeze
+
+    def initialize
+      @execution = [PROGRAM_NAME]
+      @testing = false
+    end
+
+    # TODO: Add method to remove a single command or option
+
+    # Clears @execution and starts over with only the PROGRAM_NAME
+    #
+    def clear_all!
+      @execution.clear
+      @execution = [PROGRAM_NAME]
+      self
+    end
+
+    # @return [String] the built up, whitespace-formatted start-stop-daemon
+    #   string to be executed
+    #
+    def execution
+      @execution.join(' ').strip
+    end
+
+    # Executes the built up start-stop-daemon string and throws an error if
+    # there isn't at least one command and at least one matching option.
+    #
+    # @return [true, false, nil]
+    #    true: if command was successful (exit status 0)
+    #   false: if command was unsuccessful (exit status non-zero)
+    #     nil: if command execution fails
+    #
+    # TODO: remove usage of system
+    #
+    def daemonize!
+      at_least_one_command?
+      at_least_one_matching_option?
+      system @execution
+    end
+  end
+end

data/lib/baal/commands.rb

@@ -0,0 +1,105 @@
+module Baal
+
+  # Commands contains all of the necessary methods to perform all of the
+  # possible start-stop-daemon commands.
+  #
+  module Commands
+    # Hash constant containing all possible commands.
+    COMMANDS = {
+      start: '--start',
+      stop:  '--stop',
+      status: '--status',
+      help: '--help',
+      version: '--version'
+    }.freeze
+
+    # Command that attempts to start a process specified through an option.
+    # Initially, it will check whether or not a specified process (through an
+    # option) exits. Then it will do one of the following:
+    #
+    # 1. If a specified process already exists then it will do nothing and exit
+    #    with an error status of 1 (or 0 if oknodo option is specified).
+    #
+    # 2. If a matching process does not exist, then it will start an instance of
+    #    one using one of the following options:
+    #
+    #    I. exec: an absolute pathname to an executable
+    #
+    #    II. start_as: a path_name to a process
+    #
+    def start
+      @execution.insert 1, COMMANDS[:start]
+      include_multiple_commands?
+      self
+    end
+
+    # Command that attempts to stop a specified process. Initially, it will
+    # check whether or not a specified process (through an option) exists. Then
+    # it will do one the following:
+    #
+    # 1. If a process DOES exist it will send it a signal specified by the
+    #    option:
+    #
+    #     signal: the signal to be sent to processes being stopped. If none
+    #     specified then it defaults to TERM
+    #
+    # 2. If a process DOES NOT exist it it will exit with an error status of 1
+    #    (or 1 if the oknodo option is specified).
+    #
+    # 3. If the following option is specified then start-stop-daemon will check
+    #    that the process(es) have finished:
+    #
+    #     retry: option to check whether or not process(es) finish
+    #
+    def stop
+      @execution.insert 1, COMMANDS[:stop]
+      include_multiple_commands?
+      self
+    end
+    alias kill stop
+
+    # Command that checks for whether or not a process specified by an option
+    # exists. An exit code is returned accord to the LSB Init Script Actions.
+    # TODO: provide better error messages based on LSB.
+    def status
+      @execution.insert 1, COMMANDS[:status]
+      include_multiple_commands?
+      self
+    end
+
+    # Command that shows cli help information and then exits.
+    def help
+      @execution.insert 1, COMMANDS[:help]
+      include_multiple_commands?
+      self
+    end
+
+    # Command that shows your program version of start-stop-daemon and then
+    # exits.
+    def version
+      @execution.insert 1, COMMANDS[:version]
+      include_multiple_commands?
+      self
+    end
+
+    private
+
+    # TODO: Added better errors?
+    def include_multiple_commands?
+      command_count = 0
+      COMMANDS.each do |_, command|
+        command_count += 1 if execution.include? command
+
+        raise ArgumentError, 'You can only have one command.' if command_count > 1
+      end
+    end
+
+    def at_least_one_command?
+      COMMANDS.each do |_, command|
+        return if execution.include? command
+      end
+
+      raise ArgumentError, 'You must have at least one command.'
+    end
+  end
+end

data/lib/baal/matching_options.rb

@@ -0,0 +1,125 @@
+module Baal
+
+  # MatchingOptions is a container for all methods relating to adding Matching
+  # Options to your start-stop-daemon script. Matching Options are used to
+  # target existing processes or identify new ones to be acted upon using a
+  # Command.
+  #
+  # At least one Matching Option is required to execute a start-stop-daemon
+  # script.
+  #
+  module MatchingOptions
+    # All possible Matching Options
+    MATCHING_OPTIONS = {
+      pid: '--pid',
+      ppid: '--ppid',
+      pid_file: '--pidfile',
+      exec: '--exec',
+      name: '--name',
+      user: '--user'
+    }.freeze
+
+    # Checks for a process with a specified process id.
+    #
+    # @param id [String, Integer] the process id to be targeted. Must be
+    #   greater than 0.
+    # TODO: Add error to catch for 0 or less.
+    #
+    def pid(id)
+      @execution.push "#{MATCHING_OPTIONS[:pid]}=#{id}"
+      self
+    end
+    alias with_pid pid
+
+    # Checks for a process with a specified parent process id.
+    #
+    # @param id [String, Integer] the parent process id to be targeted. Must be
+    #   greater than 0.
+    # TODO: Add error to catch for 0 or less.
+    #
+    def ppid(id)
+      @execution.push "#{MATCHING_OPTIONS[:ppid]}=#{id}"
+      self
+    end
+    alias with_ppid ppid
+
+    # Checks whether or not a process has created the pid_file.
+    #
+    # @param path [String] the path to the pid_file to be checked.
+    #
+    # WARNING: if used alone AND the old process terminated without removing
+    #          the pid_file specified by @path, then this might cause
+    #          unintended consequences.
+    #
+    def pid_file(path)
+      @execution.push "#{MATCHING_OPTIONS[:pid_file]}=#{path}"
+      self
+    end
+    alias with_pid_file pid_file
+    alias pidfile pid_file
+
+    # Used with Commands#start.
+    #
+    # Checks for processes that are instances of the executable specified by
+    # abs_path_to_exec.
+    #
+    # @param abs_path_to_exec [String] the absolute path to the executable
+    #
+    # NOTE: might not work if used with interpreted scripts, as the executable
+    #       will point to the interpreter.
+    #
+    # WARNING: take into account processes running from inside a chroot will
+    #          also be identified, so other restrictions might be needed to
+    #          avoid this.
+    #
+    def exec(abs_path_to_exec)
+      @execution.push "#{MATCHING_OPTIONS[:exec]}=#{abs_path_to_exec}"
+      self
+    end
+    alias instance_of_exec exec
+
+    # Checks for processes with the name specified by @process_name
+    #
+    # @param process_name [String] name of process
+    #
+    # NOTE: the name of the process is often the filename, but be wary that it
+    #       could have been changed by process itself
+    #
+    # NOTE: for most systems the process name is retrieved from the process
+    #       comm name from the kernel. This is typically a shortened version
+    #       of the expected process name that is 15 characters long.
+    #
+    def name(process_name)
+      @execution.push "#{MATCHING_OPTIONS[:name]}=#{process_name}"
+      self
+    end
+    alias with_name name
+
+    # Checks for processes owned by the user specified by a username or uid.
+    #
+    # @param username_or_uid [String, Symbol, Integer]
+    #
+    # WARNING: Using this matching option ALONE will cause all matching
+    #          processes to be acted upon.
+    #
+    def user(username_or_uid)
+      @execution.push "#{MATCHING_OPTIONS[:user]}=#{username_or_uid}"
+      self
+    end
+    alias username user
+    alias uid user
+    alias owned_by_user user
+    alias owned_by_username user
+    alias owned_by_uid user
+
+    private
+
+    def at_least_one_matching_option?
+      MATCHING_OPTIONS.each do |_, option|
+        return if execution.include? option
+      end
+
+      raise ArgumentError, 'You must have at least one matching option.'
+    end
+  end
+end

data/lib/baal/optional_options.rb

@@ -0,0 +1,297 @@
+module Baal
+
+  # Optional Options is a container for all methods relating to options that
+  # can be added to your start-stop-daemon script, but are not required
+  #
+  module OptionalOptions
+    class InvalidPolicyError < ArgumentError; end
+    class InvalidScheduleClassError < ArgumentError; end
+
+    # All optional options
+    OPTIONAL_OPTS = {
+      group: '--group',
+      signal: '--signal',
+      retry: '--retry',
+      start_as: '--startas',
+      test: '--test',
+      oknodo: '--oknodo',
+      quiet: '--quiet',
+      chuid: '--chuid',
+      chroot: '--chroot',
+      chdir: '--chdir',
+      background: '--background',
+      no_close: '--no-close',
+      nice_level: '--nicelevel',
+      proc_sched: '--procsched',
+      io_sched: '--iosched',
+      umask: '--umask',
+      make_pid_file: '--make-pidfile',
+      remove_pid_file: '--remove-pidfile',
+      verbose: '--verbose'
+    }.freeze
+
+    # Change to a group or group id before starting the process
+    #
+    # @param group_name_or_gid [String, Integer, Symbol] the group name or group
+    #   id to be changed to
+    #
+    def group(group_name_or_gid)
+      @execution.push "#{OPTIONAL_OPTS[:group]}=#{group_name_or_gid}"
+      self
+    end
+    alias group_name group
+    alias gid group
+    alias change_to_group group
+    alias change_to_group_name group
+    alias change_to_gid group
+
+    # Used with Commands#stop. Specifies the signal to send to the
+    # processes attempting to be stopped.
+    #
+    # @param signal[String, Symbol] the signal to send
+    #
+    def signal(signal = 'TERM')
+      @execution.push "#{OPTIONAL_OPTS[:signal]}=#{signal}"
+      self
+    end
+    alias with_signal signal
+
+    # Used with Commands#stop. Specifies that start-stop-daemon is to check
+    # whether the process(es) do finish. It will check repeatedly whether any
+    # matching processes are running, until none are. If the processes do not
+    # exit it will then take futher action as defined by the schedule.
+    #
+    # @param timeout_or_schedule [String, Integer]
+    #   If a timeout (in seconds) is specified, then the following schedule is
+    #   used:
+    #
+    #     signal/timeout/KILL/timeout, where signal is specified with
+    #     OptionalOptions#signal.
+    #
+    #  To specify a schedule: a schedule is a list of at least two items
+    #  separated by slashes; each item may be any of the following:
+    #
+    #    1. signal number or signal name, which means to send that signal
+    #    2. timeout, which means to wait that many seconds for processes to
+    #      exit
+    #    3. forever, which means to repeat the rest of the schedule forever if
+    #      necessary
+    #
+    #  If the end of the schedule is reached and forever is not specified, then
+    #  start-stop-daemon exits with the error status of 2.
+    #
+    #  WARNING: If a schedule is specified, then any signal specified with
+    #           OptionalOptions#signal is ignored.
+    #
+    # TODO: Add better arguments for constructing a schedule
+    #
+    def retry(timeout_or_schedule)
+      @execution.push "#{OPTIONAL_OPTS[:retry]}=#{timeout_or_schedule}"
+      self
+    end
+    alias retry_timeout retry
+    alias retry_schedule retry
+
+    # Used with Commands#start.
+    #
+    # Starts the process at the specified path. If not added as an option to
+    # Commands#start, the path will default to the one provided to
+    # MatchhingOptions#exec.
+    #
+    # @param path [String] path to process to attempt to start as
+    #
+    def start_as(path)
+      @execution.push "#{OPTIONAL_OPTS[:start_as]}=#{path}"
+      self
+    end
+    alias startas start_as
+
+    # Print actions that would be taken and set an appropriate return value,
+    # but take no action
+    #
+    def test
+      @execution.push OPTIONAL_OPTS[:test]
+      self
+    end
+
+    # Return an exit status of 0 instead of 1 if no actions are, or would not
+    # be, taken
+    #
+    def oknodo
+      @execution.push OPTIONAL_OPTS[:oknodo]
+      self
+    end
+
+    # Do not print informational messages; only display error messages
+    #
+    def quiet
+      @execution.push OPTIONAL_OPTS[:quiet]
+      self
+    end
+
+    # Change to the specified username or uid before starting the process.
+    #
+    # @param username_or_uid [String, Integer, Symbol] username or uid to change
+    #   to.
+    # @param group_or_gid [String, Integer, Symbol] group name or group id to
+    #   change to.
+    #
+    # NOTE: If a user is specified without a group, the primary GID for that
+    #       user is used.
+    #
+    # NOTE: Primary and supplemental groups are set as well, even if the
+    #       OptionalOptions#group option is not specified. The
+    #       OptionalOptions#group option is only groups that the user isn't
+    #       normally a member of.
+    #
+    def chuid(username_or_uid, group_or_gid = nil)
+      group_or_gid = group_or_gid.nil? ? '' : ":#{group_or_gid}"
+      @execution.push "#{OPTIONAL_OPTS[:chuid]}=#{username_or_uid}#{group_or_gid}"
+      self
+    end
+    alias change_to_user chuid
+    alias change_to_uid chuid
+
+    # Change directories and chroot to root before starting the process.
+    #
+    # @param new_root_dir [String] path to chroot to
+    #
+    # NOTE: the pid_file is written after the chroot
+    #
+    def chroot(new_root_dir)
+      @execution.push "#{OPTIONAL_OPTS[:chroot]}=#{new_root_dir}"
+      self
+    end
+
+    # Change directories to @path before starting the process.
+    #
+    # Chdir is done AFTER the chroot if the OptionalOptions#chroot option is
+    # set. When no OptionalOptions#chroot is set, start-stop-daemon will
+    # chdir to the root directory before starting the process.
+    #
+    def chdir(path)
+      @execution.push "#{OPTIONAL_OPTS[:chdir]}=#{path}"
+      self
+    end
+
+    def background
+      @execution.push OPTIONAL_OPTS[:background]
+      self
+    end
+    alias in_background background
+
+    # Only relevant when using --background
+    def no_close
+      @execution.push OPTIONAL_OPTS[:no_close]
+      self
+    end
+
+    # Alters the priority of the process before starting it.
+    #
+    # @param incr [String, Integer] amount to alter the priority level, can be
+    #   positive or negative
+    #
+    def nice_level(incr)
+      @execution.push "#{OPTIONAL_OPTS[:nice_level]}=#{incr}"
+      self
+    end
+    alias incr_nice_level nice_level
+
+    VALID_POLICIES = %w(other fifo rr).freeze
+
+    # Alters the process scheduler class and priority of the process before
+    # starting it.
+    #
+    # Default priority is 0 when executed.
+    #
+    # @param policy [String, Symbol] the process scheduler policy.
+    #   Supported values: :other, :fifo, :rr
+    # @param priority [String, Integer] the process priority
+    def proc_sched(policy, priority = nil)
+      unless VALID_POLICIES.include? policy.to_s
+        raise InvalidPolicyError, 'Invalid policy. Expected: other, fifo, rr'
+      end
+
+      priority = priority.nil? ? ' ' : ":#{priority}"
+      @execution.push "#{OPTIONAL_OPTS[:proc_sched]}=#{policy}#{priority}"
+      self
+    end
+    alias procshed proc_sched
+    alias process_schedule proc_sched
+
+    VALID_SCHEDULE_CLASSES = %w(idle best-effort real-time).freeze
+
+    # Alters the io IO scheduler class and priority of the process before
+    # starting it.
+    #
+    # Default priority is 4, unless the sched_class is :idle, then it's 7.
+    #
+    # @param sched_class [String, Symbol] the io scheduler class.
+    #   Supported values: :idle, :best-effort, :real-time
+    # @param priority [String, Integer] the process priority.
+    #
+    def io_sched(sched_class, priority = nil)
+      puts sched_class
+      unless VALID_SCHEDULE_CLASSES.include? sched_class.to_s
+        raise InvalidScheduleClassError,
+              'Invalid schedule class. Expected: idle, best-effort, real-time'
+      end
+
+      priority = priority.nil? ? ' ' : ":#{priority}"
+      @execution.push "#{OPTIONAL_OPTS[:io_sched]}=#{sched_class}#{priority}"
+      self
+    end
+    alias iosched io_sched
+    alias io_schedule io_sched
+
+    # Sets the umask of the process before starting it
+    #
+    # @param mask [String, Integer] umask value
+    def umask(mask)
+      @execution.push "#{OPTIONAL_OPTS[:umask]}=#{mask}"
+      self
+    end
+
+    # Used when starting a program that does not create its own pid file.
+    #
+    # Used together with the file specified by the MatchingOptions#pidfile
+    # option.
+    #
+    # This will place the pid into the file specified by the
+    # MatchingOptions#pidfile option, just before executing the process.
+    #
+    # NOTE: The file will only be removed if the OptionalOptions#remove_pid_file
+    # option is used.
+    #
+    # WARNING: Will not work in all cases, such as when the program being
+    #          executed  forks from its main process. Because of this, it is
+    #          usually only useful when combined with the
+    #          OptionalOptions#background option.
+    #
+    def make_pid_file
+      @execution.push OPTIONAL_OPTS[:make_pid_file]
+      self
+    end
+    alias make_pidfile make_pid_file
+
+    # Used when stopping a program that will NOT remove its own pid file.
+    #
+    # Used together with the file specified by the MatchingOptions#pidfile
+    # option.
+    #
+    # This will remove the file specified by the MatchingOptions#pidfile
+    # option.
+    #
+    def remove_pid_file
+      @execution.push OPTIONAL_OPTS[:remove_pid_file]
+      self
+    end
+    alias remove_pidfile remove_pid_file
+
+    # Print verbose informational messages when executing the script
+    def verbose
+      @execution.push OPTIONAL_OPTS[:verbose]
+      self
+    end
+  end
+end

data/lib/baal/version.rb

@@ -0,0 +1,3 @@
+module Baal
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: baal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lukas Nimmo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- Lukas.nimmo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- baal.gemspec
+- lib/baal.rb
+- lib/baal/commands.rb
+- lib/baal/matching_options.rb
+- lib/baal/optional_options.rb
+- lib/baal/version.rb
+homepage: https://github.com/numbluk/baal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Baal is a Ruby wrapper for start-stop-daemon that attempts to make your start-stop-daemon
+  scripts easier to build and read while still providing the same options you are
+  used to. Baal, through start-stop-daemon, provides a myriad of ways to start new
+  daemon processes and check the status of and stop existing ones.
+test_files: []